"""
Adept MobileRobots Robotics Interface for Applications (ARIA)
Copyright (C) 2004-2005 ActivMedia Robotics LLC
Copyright (C) 2006-2010 MobileRobots Inc.
Copyright (C) 2011-2014 Adept Technology

     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
     the Free Software Foundation; either version 2 of the License, or
     (at your option) any later version.

     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU General Public License for more details.

     You should have received a copy of the GNU General Public License
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
Adept MobileRobots for information about a commercial version of ARIA at 
robots@mobilerobots.com or 
Adept MobileRobots, 10 Columbia Drive, Amherst, NH 03031; +1-603-881-7960
"""
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

"""
Python wrapper library for ArNetworking
"""

from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_ArNetworkingPy', [dirname(__file__)])
        except ImportError:
            import _ArNetworkingPy
            return _ArNetworkingPy
        if fp is not None:
            try:
                _mod = imp.load_module('_ArNetworkingPy', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _ArNetworkingPy = swig_import_helper()
    del swig_import_helper
else:
    import _ArNetworkingPy
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


import AriaPy
SWIG_IMPORTED_ARIA = _ArNetworkingPy.SWIG_IMPORTED_ARIA
class ArNetPacket(AriaPy.ArBasePacket):
    """Proxy of C++ ArNetPacket class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArBasePacket]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacket, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArBasePacket]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacket, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, UByte2 bufferSize = ArNetPacket::MAX_LENGTH+5) -> ArNetPacket
        __init__(self) -> ArNetPacket
        __init__(self, ArNetPacket other) -> ArNetPacket
        """
        this = _ArNetworkingPy.new_ArNetPacket(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacket
    __del__ = lambda self : None;
    def setCommand(self, *args):
        """setCommand(self, UByte2 command)"""
        return _ArNetworkingPy.ArNetPacket_setCommand(self, *args)

    def getCommand(self):
        """getCommand(self) -> UByte2"""
        return _ArNetworkingPy.ArNetPacket_getCommand(self)

    SIZE_OF_LENGTH = _ArNetworkingPy.ArNetPacket_SIZE_OF_LENGTH
    MAX_LENGTH = _ArNetworkingPy.ArNetPacket_MAX_LENGTH
    HEADER_LENGTH = _ArNetworkingPy.ArNetPacket_HEADER_LENGTH
    FOOTER_LENGTH = _ArNetworkingPy.ArNetPacket_FOOTER_LENGTH
    MAX_DATA_LENGTH = _ArNetworkingPy.ArNetPacket_MAX_DATA_LENGTH
    def doubleToBuf(self, *args):
        """doubleToBuf(self, double val)"""
        return _ArNetworkingPy.ArNetPacket_doubleToBuf(self, *args)

    def bufToDouble(self):
        """bufToDouble(self) -> double"""
        return _ArNetworkingPy.ArNetPacket_bufToDouble(self)

    def empty(self):
        """empty(self)"""
        return _ArNetworkingPy.ArNetPacket_empty(self)

    def finalizePacket(self):
        """finalizePacket(self)"""
        return _ArNetworkingPy.ArNetPacket_finalizePacket(self)

    def resetRead(self):
        """resetRead(self)"""
        return _ArNetworkingPy.ArNetPacket_resetRead(self)

    def duplicatePacket(self, *args):
        """duplicatePacket(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArNetPacket_duplicatePacket(self, *args)

    def verifyCheckSum(self):
        """verifyCheckSum(self) -> bool"""
        return _ArNetworkingPy.ArNetPacket_verifyCheckSum(self)

    def calcCheckSum(self):
        """calcCheckSum(self) -> Byte2"""
        return _ArNetworkingPy.ArNetPacket_calcCheckSum(self)

    def getAddedFooter(self):
        """getAddedFooter(self) -> bool"""
        return _ArNetworkingPy.ArNetPacket_getAddedFooter(self)

    def setAddedFooter(self, *args):
        """setAddedFooter(self, bool addedFooter)"""
        return _ArNetworkingPy.ArNetPacket_setAddedFooter(self, *args)

    TCP = _ArNetworkingPy.ArNetPacket_TCP
    UDP = _ArNetworkingPy.ArNetPacket_UDP
    def getPacketSource(self):
        """getPacketSource(self) -> PacketSource"""
        return _ArNetworkingPy.ArNetPacket_getPacketSource(self)

    def setPacketSource(self, *args):
        """setPacketSource(self, PacketSource source)"""
        return _ArNetworkingPy.ArNetPacket_setPacketSource(self, *args)

    def setArbitraryString(self, *args):
        """setArbitraryString(self, char string)"""
        return _ArNetworkingPy.ArNetPacket_setArbitraryString(self, *args)

    def getArbitraryString(self):
        """getArbitraryString(self) -> char"""
        return _ArNetworkingPy.ArNetPacket_getArbitraryString(self)

ArNetPacket_swigregister = _ArNetworkingPy.ArNetPacket_swigregister
ArNetPacket_swigregister(ArNetPacket)

class ArServerBase(AriaPy.ArASyncTask):
    """Proxy of C++ ArServerBase class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerBase, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerBase, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins", 
            char backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer = False, 
            bool slaveServer = False, 
            bool logPasswordFailureVerbosely = False, 
            bool allowSlowPackets = True, 
            bool allowIdlePackets = True, 
            int maxClientsAllowed = -1, 
            int warningTimeMSec = 250) -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins", 
            char backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer = False, 
            bool slaveServer = False, 
            bool logPasswordFailureVerbosely = False, 
            bool allowSlowPackets = True, 
            bool allowIdlePackets = True, 
            int maxClientsAllowed = -1) -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins", 
            char backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer = False, 
            bool slaveServer = False, 
            bool logPasswordFailureVerbosely = False, 
            bool allowSlowPackets = True, 
            bool allowIdlePackets = True) -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins", 
            char backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer = False, 
            bool slaveServer = False, 
            bool logPasswordFailureVerbosely = False, 
            bool allowSlowPackets = True) -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins", 
            char backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer = False, 
            bool slaveServer = False, 
            bool logPasswordFailureVerbosely = False) -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins", 
            char backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer = False, 
            bool slaveServer = False) -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins", 
            char backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)", 
            bool masterServer = False) -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins", 
            char backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won\'t happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)") -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True, 
            char backupTimeoutName = "RobotToClientTimeoutInMins") -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "", bool addBackupTimeoutToConfig = True) -> ArServerBase
        __init__(self, bool addAriaExitCB = True, char serverName = "") -> ArServerBase
        __init__(self, bool addAriaExitCB = True) -> ArServerBase
        __init__(self) -> ArServerBase
        """
        this = _ArNetworkingPy.new_ArServerBase(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerBase
    __del__ = lambda self : None;
    def open(self, *args):
        """
        open(self, unsigned int port, char openOnIP = None, bool tcpOnly = False) -> bool
        open(self, unsigned int port, char openOnIP = None) -> bool
        open(self, unsigned int port) -> bool
        """
        return _ArNetworkingPy.ArServerBase_open(self, *args)

    def close(self):
        """close(self)"""
        return _ArNetworkingPy.ArServerBase_close(self)

    def loopOnce(self):
        """loopOnce(self)"""
        return _ArNetworkingPy.ArServerBase_loopOnce(self)

    def addData(self, *args):
        """
        addData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None, 
            char dataFlags = None) -> bool
        addData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None) -> bool
        addData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerBase_addData(self, *args)

    def loadUserInfo(self, *args):
        """
        loadUserInfo(self, char fileName, char baseDirectory = "") -> bool
        loadUserInfo(self, char fileName) -> bool
        """
        return _ArNetworkingPy.ArServerBase_loadUserInfo(self, *args)

    def logUserInfo(self):
        """logUserInfo(self)"""
        return _ArNetworkingPy.ArServerBase_logUserInfo(self)

    def logCommandGroups(self):
        """logCommandGroups(self)"""
        return _ArNetworkingPy.ArServerBase_logCommandGroups(self)

    def logCommandGroupsToFile(self, *args):
        """logCommandGroupsToFile(self, char fileName)"""
        return _ArNetworkingPy.ArServerBase_logCommandGroupsToFile(self, *args)

    def setGroupDescription(self, *args):
        """setGroupDescription(self, char GrpName, char GrpDesc)"""
        return _ArNetworkingPy.ArServerBase_setGroupDescription(self, *args)

    def logGroupDescriptions(self):
        """logGroupDescriptions(self)"""
        return _ArNetworkingPy.ArServerBase_logGroupDescriptions(self)

    def logGroupDescriptionsToFile(self, *args):
        """logGroupDescriptionsToFile(self, char fileName)"""
        return _ArNetworkingPy.ArServerBase_logGroupDescriptionsToFile(self, *args)

    def setServerKey(self, *args):
        """setServerKey(self, char serverKey)"""
        return _ArNetworkingPy.ArServerBase_setServerKey(self, *args)

    def rejectSinceUsingCentralServer(self, *args):
        """rejectSinceUsingCentralServer(self, char centralServerIPString)"""
        return _ArNetworkingPy.ArServerBase_rejectSinceUsingCentralServer(self, *args)

    def enforceProtocolVersion(self, *args):
        """enforceProtocolVersion(self, char protocolVersion)"""
        return _ArNetworkingPy.ArServerBase_enforceProtocolVersion(self, *args)

    def enforceType(self, *args):
        """enforceType(self, Type type)"""
        return _ArNetworkingPy.ArServerBase_enforceType(self, *args)

    def setBackupTimeout(self, *args):
        """setBackupTimeout(self, double timeoutInMins)"""
        return _ArNetworkingPy.ArServerBase_setBackupTimeout(self, *args)

    def run(self):
        """run(self)"""
        return _ArNetworkingPy.ArServerBase_run(self)

    def runAsync(self):
        """runAsync(self)"""
        return _ArNetworkingPy.ArServerBase_runAsync(self)

    def logConnections(self, prefix = ""):
        """
        logConnections(self, char prefix = "")
        logConnections(self)
        """
        return _ArNetworkingPy.ArServerBase_logConnections(self, prefix)

    def getNumClients(self):
        """getNumClients(self) -> int"""
        return _ArNetworkingPy.ArServerBase_getNumClients(self)

    def findCommandFromName(self, *args):
        """findCommandFromName(self, char command) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_findCommandFromName(self, *args)

    def broadcastPacketTcp(self, *args):
        """broadcastPacketTcp(self, ArNetPacket packet, char name) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcp(self, *args)

    def broadcastPacketTcpToMatching(self, *args):
        """
        broadcastPacketTcpToMatching(self, ArNetPacket packet, char name, ArServerClientIdentifier identifier, 
            bool matchConnectionID = False) -> bool
        broadcastPacketTcpToMatching(self, ArNetPacket packet, char name, ArServerClientIdentifier identifier) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpToMatching(self, *args)

    def broadcastPacketTcpWithExclusion(self, *args):
        """
        broadcastPacketTcpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match = False, ArServerClientIdentifier identifier = ArServerClientIdentifier(), 
            bool matchConnectionID = False) -> bool
        broadcastPacketTcpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match = False, ArServerClientIdentifier identifier = ArServerClientIdentifier()) -> bool
        broadcastPacketTcpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match = False) -> bool
        broadcastPacketTcpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpWithExclusion(self, *args)

    def broadcastPacketUdp(self, *args):
        """broadcastPacketUdp(self, ArNetPacket packet, char name) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdp(self, *args)

    def broadcastPacketUdpWithExclusion(self, *args):
        """
        broadcastPacketUdpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match = False, ArServerClientIdentifier identifier = ArServerClientIdentifier(), 
            bool matchConnectionID = False) -> bool
        broadcastPacketUdpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match = False, ArServerClientIdentifier identifier = ArServerClientIdentifier()) -> bool
        broadcastPacketUdpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient, 
            bool match = False) -> bool
        broadcastPacketUdpWithExclusion(self, ArNetPacket packet, char name, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpWithExclusion(self, *args)

    def broadcastPacketUdpToMatching(self, *args):
        """
        broadcastPacketUdpToMatching(self, ArNetPacket packet, char name, ArServerClientIdentifier identifier, 
            bool matchConnectionID) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpToMatching(self, *args)

    def sleepAfterSend(self, *args):
        """sleepAfterSend(self, int msecDelay)"""
        return _ArNetworkingPy.ArServerBase_sleepAfterSend(self, *args)

    def idleProcessingPending(self):
        """idleProcessingPending(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_idleProcessingPending(self)

    def processPacket(self, *args):
        """processPacket(self, ArNetPacket packet, sockaddr_in sin)"""
        return _ArNetworkingPy.ArServerBase_processPacket(self, *args)

    def sendUdp(self, *args):
        """sendUdp(self, ArNetPacket packet, sockaddr_in sin) -> bool"""
        return _ArNetworkingPy.ArServerBase_sendUdp(self, *args)

    def logTracking(self, terse = True):
        """
        logTracking(self, bool terse = True)
        logTracking(self)
        """
        return _ArNetworkingPy.ArServerBase_logTracking(self, terse)

    def resetTracking(self):
        """resetTracking(self)"""
        return _ArNetworkingPy.ArServerBase_resetTracking(self)

    def runThread(self, *args):
        """runThread(self, void arg) -> void"""
        return _ArNetworkingPy.ArServerBase_runThread(self, *args)

    def getTcpPort(self):
        """getTcpPort(self) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_getTcpPort(self)

    def getUdpPort(self):
        """getUdpPort(self) -> unsigned int"""
        return _ArNetworkingPy.ArServerBase_getUdpPort(self)

    def getOpenOnIP(self):
        """getOpenOnIP(self) -> char"""
        return _ArNetworkingPy.ArServerBase_getOpenOnIP(self)

    def addCycleCallback(self, *args):
        """addCycleCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerBase_addCycleCallback(self, *args)

    def remCycleCallback(self, *args):
        """remCycleCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerBase_remCycleCallback(self, *args)

    def addClientRemovedCallback(self, *args):
        """addClientRemovedCallback(self, ArFunctor1<(p.ArServerClient)> functor)"""
        return _ArNetworkingPy.ArServerBase_addClientRemovedCallback(self, *args)

    def remClientRemovedCallback(self, *args):
        """remClientRemovedCallback(self, ArFunctor1<(p.ArServerClient)> functor)"""
        return _ArNetworkingPy.ArServerBase_remClientRemovedCallback(self, *args)

    def makeNewServerClientFromSocket(self, *args):
        """makeNewServerClientFromSocket(self, ArSocket socket, bool overrideGeneralReject) -> ArServerClient"""
        return _ArNetworkingPy.ArServerBase_makeNewServerClientFromSocket(self, *args)

    def getUserInfo(self):
        """getUserInfo(self) -> ArServerUserInfo"""
        return _ArNetworkingPy.ArServerBase_getUserInfo(self)

    def setUserInfo(self, *args):
        """setUserInfo(self, ArServerUserInfo userInfo)"""
        return _ArNetworkingPy.ArServerBase_setUserInfo(self, *args)

    def addDataAdvanced(self, *args):
        """
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None, 
            char dataFlags = None, unsigned int commandNumber = 0, 
            ArFunctor2<(long,unsigned int)> requestChangedFunctor = None, 
            ArRetFunctor2<(bool,p.ArServerClient,p.ArNetPacket)> requestOnceFunctor = None) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None, 
            char dataFlags = None, unsigned int commandNumber = 0, 
            ArFunctor2<(long,unsigned int)> requestChangedFunctor = None) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None, 
            char dataFlags = None, unsigned int commandNumber = 0) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None, 
            char dataFlags = None) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None) -> bool
        addDataAdvanced(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerBase_addDataAdvanced(self, *args)

    def setAdditionalDataFlags(self, *args):
        """setAdditionalDataFlags(self, char additionalDataFlags)"""
        return _ArNetworkingPy.ArServerBase_setAdditionalDataFlags(self, *args)

    def getFrequency(self, *args):
        """
        getFrequency(self, unsigned int command, bool internalCall = False) -> long
        getFrequency(self, unsigned int command) -> long
        """
        return _ArNetworkingPy.ArServerBase_getFrequency(self, *args)

    def broadcastPacketTcpByCommand(self, *args):
        """broadcastPacketTcpByCommand(self, ArNetPacket packet, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpByCommand(self, *args)

    def broadcastPacketTcpByCommandWithExclusion(self, *args):
        """
        broadcastPacketTcpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match = False, ArServerClientIdentifier identifier = ArServerClientIdentifier(), 
            bool matchConnectionID = False) -> bool
        broadcastPacketTcpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match = False, ArServerClientIdentifier identifier = ArServerClientIdentifier()) -> bool
        broadcastPacketTcpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match = False) -> bool
        broadcastPacketTcpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketTcpByCommandWithExclusion(self, *args)

    def broadcastPacketUdpByCommand(self, *args):
        """broadcastPacketUdpByCommand(self, ArNetPacket packet, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpByCommand(self, *args)

    def broadcastPacketUdpByCommandWithExclusion(self, *args):
        """
        broadcastPacketUdpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match = False, ArServerClientIdentifier identifier = ArServerClientIdentifier(), 
            bool matchConnectionID = False) -> bool
        broadcastPacketUdpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match = False, ArServerClientIdentifier identifier = ArServerClientIdentifier()) -> bool
        broadcastPacketUdpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient, 
            bool match = False) -> bool
        broadcastPacketUdpByCommandWithExclusion(self, ArNetPacket packet, unsigned int command, ArServerClient excludeClient) -> bool
        """
        return _ArNetworkingPy.ArServerBase_broadcastPacketUdpByCommandWithExclusion(self, *args)

    def closeConnectionID(self, *args):
        """closeConnectionID(self, UByte4 idNum)"""
        return _ArNetworkingPy.ArServerBase_closeConnectionID(self, *args)

    def dataHasFlag(self, *args):
        """dataHasFlag(self, char name, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerBase_dataHasFlag(self, *args)

    def dataHasFlagByCommand(self, *args):
        """dataHasFlagByCommand(self, unsigned int command, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerBase_dataHasFlagByCommand(self, *args)

    def setDebugLogging(self, debugLogging = False):
        """
        setDebugLogging(self, bool debugLogging = False)
        setDebugLogging(self)
        """
        return _ArNetworkingPy.ArServerBase_setDebugLogging(self, debugLogging)

    def getDebugLogging(self):
        """getDebugLogging(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_getDebugLogging(self)

    def getMostClients(self):
        """getMostClients(self) -> int"""
        return _ArNetworkingPy.ArServerBase_getMostClients(self)

    def allowingIdlePackets(self):
        """allowingIdlePackets(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_allowingIdlePackets(self)

    def addIdleSingleShotCallback(self, *args):
        """addIdleSingleShotCallback(self, ArFunctor functor) -> bool"""
        return _ArNetworkingPy.ArServerBase_addIdleSingleShotCallback(self, *args)

    def hasSlowPackets(self):
        """hasSlowPackets(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasSlowPackets(self)

    def hasIdlePackets(self):
        """hasIdlePackets(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasIdlePackets(self)

    def hasIdleCallbacks(self):
        """hasIdleCallbacks(self) -> bool"""
        return _ArNetworkingPy.ArServerBase_hasIdleCallbacks(self)

    def internalSetNumClients(self, *args):
        """internalSetNumClients(self, int numClients)"""
        return _ArNetworkingPy.ArServerBase_internalSetNumClients(self, *args)

    def addTooManyClientsCB(self, *args):
        """
        addTooManyClientsCB(self, ArFunctor1_CString functor, int position = 50)
        addTooManyClientsCB(self, ArFunctor1_CString functor)
        """
        return _ArNetworkingPy.ArServerBase_addTooManyClientsCB(self, *args)

    def remTooManyClientsCB(self, *args):
        """remTooManyClientsCB(self, ArFunctor1_CString functor)"""
        return _ArNetworkingPy.ArServerBase_remTooManyClientsCB(self, *args)

    def internalSetDefaultFrequency(self, *args):
        """internalSetDefaultFrequency(self, char command, int frequency) -> bool"""
        return _ArNetworkingPy.ArServerBase_internalSetDefaultFrequency(self, *args)

    def internalLockup(self):
        """internalLockup(self)"""
        return _ArNetworkingPy.ArServerBase_internalLockup(self)

ArServerBase_swigregister = _ArNetworkingPy.ArServerBase_swigregister
ArServerBase_swigregister(ArServerBase)

class ArServerMode(_object):
    """Proxy of C++ ArServerMode class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerMode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerMode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerMode
    __del__ = lambda self : None;
    def getActionGroup(self):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerMode_getActionGroup(self)

    def activate(self):
        """activate(self)"""
        return _ArNetworkingPy.ArServerMode_activate(self)

    def deactivate(self):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerMode_deactivate(self)

    def activationDenied(self):
        """activationDenied(self)"""
        return _ArNetworkingPy.ArServerMode_activationDenied(self)

    def userTask(self):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerMode_userTask(self)

    def requestUnlock(self):
        """requestUnlock(self)"""
        return _ArNetworkingPy.ArServerMode_requestUnlock(self)

    def forceUnlock(self):
        """forceUnlock(self)"""
        return _ArNetworkingPy.ArServerMode_forceUnlock(self)

    def lockMode(self, willUnlockIfRequested = False):
        """
        lockMode(self, bool willUnlockIfRequested = False)
        lockMode(self)
        """
        return _ArNetworkingPy.ArServerMode_lockMode(self, willUnlockIfRequested)

    def unlockMode(self):
        """unlockMode(self)"""
        return _ArNetworkingPy.ArServerMode_unlockMode(self)

    def getMode(self):
        """getMode(self) -> char"""
        return _ArNetworkingPy.ArServerMode_getMode(self)

    def getStatus(self):
        """getStatus(self) -> char"""
        return _ArNetworkingPy.ArServerMode_getStatus(self)

    def getExtendedStatus(self):
        """getExtendedStatus(self) -> char"""
        return _ArNetworkingPy.ArServerMode_getExtendedStatus(self)

    def getActiveModeModeString():
        """getActiveModeModeString() -> char"""
        return _ArNetworkingPy.ArServerMode_getActiveModeModeString()

    if _newclass:getActiveModeModeString = staticmethod(getActiveModeModeString)
    __swig_getmethods__["getActiveModeModeString"] = lambda x: getActiveModeModeString
    def getActiveModeStatusString():
        """getActiveModeStatusString() -> char"""
        return _ArNetworkingPy.ArServerMode_getActiveModeStatusString()

    if _newclass:getActiveModeStatusString = staticmethod(getActiveModeStatusString)
    __swig_getmethods__["getActiveModeStatusString"] = lambda x: getActiveModeStatusString
    def getActiveModeExtendedStatusString():
        """getActiveModeExtendedStatusString() -> char"""
        return _ArNetworkingPy.ArServerMode_getActiveModeExtendedStatusString()

    if _newclass:getActiveModeExtendedStatusString = staticmethod(getActiveModeExtendedStatusString)
    __swig_getmethods__["getActiveModeExtendedStatusString"] = lambda x: getActiveModeExtendedStatusString
    def getName(self):
        """getName(self) -> char"""
        return _ArNetworkingPy.ArServerMode_getName(self)

    def isActive(self):
        """isActive(self) -> bool"""
        return _ArNetworkingPy.ArServerMode_isActive(self)

    def isLocked():
        """isLocked() -> bool"""
        return _ArNetworkingPy.ArServerMode_isLocked()

    if _newclass:isLocked = staticmethod(isLocked)
    __swig_getmethods__["isLocked"] = lambda x: isLocked
    def willUnlockIfRequested():
        """willUnlockIfRequested() -> bool"""
        return _ArNetworkingPy.ArServerMode_willUnlockIfRequested()

    if _newclass:willUnlockIfRequested = staticmethod(willUnlockIfRequested)
    __swig_getmethods__["willUnlockIfRequested"] = lambda x: willUnlockIfRequested
    def getActiveMode():
        """getActiveMode() -> ArServerMode"""
        return _ArNetworkingPy.ArServerMode_getActiveMode()

    if _newclass:getActiveMode = staticmethod(getActiveMode)
    __swig_getmethods__["getActiveMode"] = lambda x: getActiveMode
    def hasSetActivityTime(self):
        """hasSetActivityTime(self) -> bool"""
        return _ArNetworkingPy.ArServerMode_hasSetActivityTime(self)

    def getActivityTime(self):
        """getActivityTime(self) -> ArTime"""
        return _ArNetworkingPy.ArServerMode_getActivityTime(self)

    def setActivityTimeToNow(self):
        """setActivityTimeToNow(self)"""
        return _ArNetworkingPy.ArServerMode_setActivityTimeToNow(self)

    def getActiveModeActivityTimeSecSince():
        """getActiveModeActivityTimeSecSince() -> int"""
        return _ArNetworkingPy.ArServerMode_getActiveModeActivityTimeSecSince()

    if _newclass:getActiveModeActivityTimeSecSince = staticmethod(getActiveModeActivityTimeSecSince)
    __swig_getmethods__["getActiveModeActivityTimeSecSince"] = lambda x: getActiveModeActivityTimeSecSince
    def getActiveModeSetActivityThisCycle():
        """getActiveModeSetActivityThisCycle() -> bool"""
        return _ArNetworkingPy.ArServerMode_getActiveModeSetActivityThisCycle()

    if _newclass:getActiveModeSetActivityThisCycle = staticmethod(getActiveModeSetActivityThisCycle)
    __swig_getmethods__["getActiveModeSetActivityThisCycle"] = lambda x: getActiveModeSetActivityThisCycle
    def addAsDefaultMode(self, *args):
        """
        addAsDefaultMode(self, Pos pos = LAST)
        addAsDefaultMode(self)
        """
        return _ArNetworkingPy.ArServerMode_addAsDefaultMode(self, *args)

    def checkDefault(self):
        """checkDefault(self)"""
        return _ArNetworkingPy.ArServerMode_checkDefault(self)

    def setMode(self, *args):
        """setMode(self, char str)"""
        return _ArNetworkingPy.ArServerMode_setMode(self, *args)

    def setStatus(self, *args):
        """setStatus(self, char str)"""
        return _ArNetworkingPy.ArServerMode_setStatus(self, *args)

    def isAutoResumeAfterInterrupt(self):
        """isAutoResumeAfterInterrupt(self) -> bool"""
        return _ArNetworkingPy.ArServerMode_isAutoResumeAfterInterrupt(self)

    def addModeData(self, *args):
        """
        addModeData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None, 
            char dataFlags = None) -> bool
        addModeData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription, char commandGroup = None) -> bool
        addModeData(self, char name, char description, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, 
            char returnDescription) -> bool
        """
        return _ArNetworkingPy.ArServerMode_addModeData(self, *args)

    def getModeDataList(*args):
        """getModeDataList(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeDataList(*args)

    if _newclass:getModeDataList = staticmethod(getModeDataList)
    __swig_getmethods__["getModeDataList"] = lambda x: getModeDataList
    def getModeInfo(*args):
        """getModeInfo(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeInfo(*args)

    if _newclass:getModeInfo = staticmethod(getModeInfo)
    __swig_getmethods__["getModeInfo"] = lambda x: getModeInfo
    def getModeBusy(*args):
        """getModeBusy(ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerMode_getModeBusy(*args)

    if _newclass:getModeBusy = staticmethod(getModeBusy)
    __swig_getmethods__["getModeBusy"] = lambda x: getModeBusy
    def addActivateCallback(self, *args):
        """
        addActivateCallback(self, ArFunctor functor, int position = 50)
        addActivateCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addActivateCallback(self, *args)

    def remActivateCallback(self, *args):
        """remActivateCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remActivateCallback(self, *args)

    def addDeactivateCallback(self, *args):
        """
        addDeactivateCallback(self, ArFunctor functor, int position = 50)
        addDeactivateCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addDeactivateCallback(self, *args)

    def remDeactivateCallback(self, *args):
        """remDeactivateCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remDeactivateCallback(self, *args)

    def addSingleShotDeactivateCallback(self, *args):
        """
        addSingleShotDeactivateCallback(self, ArFunctor functor, int position = 50)
        addSingleShotDeactivateCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addSingleShotDeactivateCallback(self, *args)

    def remSingleShotDeactivateCallback(self, *args):
        """remSingleShotDeactivateCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remSingleShotDeactivateCallback(self, *args)

    def addSingleShotPostDeactivateCallback(self, *args):
        """
        addSingleShotPostDeactivateCallback(self, ArFunctor functor, int position = 50)
        addSingleShotPostDeactivateCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerMode_addSingleShotPostDeactivateCallback(self, *args)

    def remSingleShotPostDeactivateCallback(self, *args):
        """remSingleShotPostDeactivateCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerMode_remSingleShotPostDeactivateCallback(self, *args)

    def getIdleMode():
        """getIdleMode() -> ArServerModeIdle"""
        return _ArNetworkingPy.ArServerMode_getIdleMode()

    if _newclass:getIdleMode = staticmethod(getIdleMode)
    __swig_getmethods__["getIdleMode"] = lambda x: getIdleMode
ArServerMode_swigregister = _ArNetworkingPy.ArServerMode_swigregister
ArServerMode_swigregister(ArServerMode)

def ArServerMode_getActiveModeModeString():
  """ArServerMode_getActiveModeModeString() -> char"""
  return _ArNetworkingPy.ArServerMode_getActiveModeModeString()

def ArServerMode_getActiveModeStatusString():
  """ArServerMode_getActiveModeStatusString() -> char"""
  return _ArNetworkingPy.ArServerMode_getActiveModeStatusString()

def ArServerMode_getActiveModeExtendedStatusString():
  """ArServerMode_getActiveModeExtendedStatusString() -> char"""
  return _ArNetworkingPy.ArServerMode_getActiveModeExtendedStatusString()

def ArServerMode_isLocked():
  """ArServerMode_isLocked() -> bool"""
  return _ArNetworkingPy.ArServerMode_isLocked()

def ArServerMode_willUnlockIfRequested():
  """ArServerMode_willUnlockIfRequested() -> bool"""
  return _ArNetworkingPy.ArServerMode_willUnlockIfRequested()

def ArServerMode_getActiveMode():
  """ArServerMode_getActiveMode() -> ArServerMode"""
  return _ArNetworkingPy.ArServerMode_getActiveMode()

def ArServerMode_getActiveModeActivityTimeSecSince():
  """ArServerMode_getActiveModeActivityTimeSecSince() -> int"""
  return _ArNetworkingPy.ArServerMode_getActiveModeActivityTimeSecSince()

def ArServerMode_getActiveModeSetActivityThisCycle():
  """ArServerMode_getActiveModeSetActivityThisCycle() -> bool"""
  return _ArNetworkingPy.ArServerMode_getActiveModeSetActivityThisCycle()

def ArServerMode_getModeDataList(*args):
  """ArServerMode_getModeDataList(ArServerClient client, ArNetPacket packet)"""
  return _ArNetworkingPy.ArServerMode_getModeDataList(*args)

def ArServerMode_getModeInfo(*args):
  """ArServerMode_getModeInfo(ArServerClient client, ArNetPacket packet)"""
  return _ArNetworkingPy.ArServerMode_getModeInfo(*args)

def ArServerMode_getModeBusy(*args):
  """ArServerMode_getModeBusy(ArServerClient client, ArNetPacket packet)"""
  return _ArNetworkingPy.ArServerMode_getModeBusy(*args)

def ArServerMode_getIdleMode():
  """ArServerMode_getIdleMode() -> ArServerModeIdle"""
  return _ArNetworkingPy.ArServerMode_getIdleMode()

class ArClientArg(_object):
    """Proxy of C++ ArClientArg class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientArg, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientArg, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, bool isDisplayHintParsed = False, Priority lastPriority = LAST_PRIORITY, 
            int version = 1, bool isSingleParam = False) -> ArClientArg
        __init__(self, bool isDisplayHintParsed = False, Priority lastPriority = LAST_PRIORITY, 
            int version = 1) -> ArClientArg
        __init__(self, bool isDisplayHintParsed = False, Priority lastPriority = LAST_PRIORITY) -> ArClientArg
        __init__(self, bool isDisplayHintParsed = False) -> ArClientArg
        __init__(self) -> ArClientArg
        """
        this = _ArNetworkingPy.new_ArClientArg(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientArg
    __del__ = lambda self : None;
    def isSendableParamType(*args):
        """
        isSendableParamType(ArConfigArg arg, bool isIncludeSeparator = True) -> bool
        isSendableParamType(ArConfigArg arg) -> bool
        """
        return _ArNetworkingPy.ArClientArg_isSendableParamType(*args)

    if _newclass:isSendableParamType = staticmethod(isSendableParamType)
    __swig_getmethods__["isSendableParamType"] = lambda x: isSendableParamType
    def createArg(self, *args):
        """
        createArg(self, ArNetPacket packet, ArConfigArg argOut, string parentPathNameOut = None) -> bool
        createArg(self, ArNetPacket packet, ArConfigArg argOut) -> bool
        """
        return _ArNetworkingPy.ArClientArg_createArg(self, *args)

    def createPacket(self, *args):
        """
        createPacket(self, ArConfigArg arg, ArNetPacket packet, char parentPathName = None) -> bool
        createPacket(self, ArConfigArg arg, ArNetPacket packet) -> bool
        """
        return _ArNetworkingPy.ArClientArg_createPacket(self, *args)

    def bufToArgValue(self, *args):
        """bufToArgValue(self, ArNetPacket packet, ArConfigArg arg) -> bool"""
        return _ArNetworkingPy.ArClientArg_bufToArgValue(self, *args)

    def argValueToBuf(self, *args):
        """argValueToBuf(self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_argValueToBuf(self, *args)

    def argTextToBuf(self, *args):
        """argTextToBuf(self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_argTextToBuf(self, *args)

    def addArgTextToPacket(self, *args):
        """addArgTextToPacket(self, ArConfigArg arg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_addArgTextToPacket(self, *args)

    def addAncestorListToPacket(self, *args):
        """
        addAncestorListToPacket(self, std::list<(p.ArConfigArg,std::allocator<(p.ArConfigArg)>)> ancestorList, 
            ArNetPacket packet) -> bool
        """
        return _ArNetworkingPy.ArClientArg_addAncestorListToPacket(self, *args)

    def addListBeginToPacket(self, *args):
        """addListBeginToPacket(self, ArConfigArg parentArg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_addListBeginToPacket(self, *args)

    def addListEndToPacket(self, *args):
        """addListEndToPacket(self, ArConfigArg parentArg, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientArg_addListEndToPacket(self, *args)

ArClientArg_swigregister = _ArNetworkingPy.ArClientArg_swigregister
ArClientArg_swigregister(ArClientArg)

def ArClientArg_isSendableParamType(*args):
  """
    isSendableParamType(ArConfigArg arg, bool isIncludeSeparator = True) -> bool
    ArClientArg_isSendableParamType(ArConfigArg arg) -> bool
    """
  return _ArNetworkingPy.ArClientArg_isSendableParamType(*args)

class ArClientBase(AriaPy.ArASyncTask):
    """Proxy of C++ ArClientBase class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientBase, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArASyncTask]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientBase, name)
    __repr__ = _swig_repr
    STATE_NO_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_NO_CONNECTION
    STATE_FAILED_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_FAILED_CONNECTION
    STATE_OPENED_SOCKET = _ArNetworkingPy.ArClientBase_STATE_OPENED_SOCKET
    STATE_EXCHANGED_INTROS = _ArNetworkingPy.ArClientBase_STATE_EXCHANGED_INTROS
    STATE_REJECTED = _ArNetworkingPy.ArClientBase_STATE_REJECTED
    STATE_WAITING_LIST = _ArNetworkingPy.ArClientBase_STATE_WAITING_LIST
    STATE_CONNECTED = _ArNetworkingPy.ArClientBase_STATE_CONNECTED
    STATE_LOST_CONNECTION = _ArNetworkingPy.ArClientBase_STATE_LOST_CONNECTION
    CLIENT_KEY_LENGTH = _ArNetworkingPy.ArClientBase_CLIENT_KEY_LENGTH
    NON_BLOCKING_CONTINUE = _ArNetworkingPy.ArClientBase_NON_BLOCKING_CONTINUE
    NON_BLOCKING_CONNECTED = _ArNetworkingPy.ArClientBase_NON_BLOCKING_CONNECTED
    NON_BLOCKING_FAILED = _ArNetworkingPy.ArClientBase_NON_BLOCKING_FAILED
    def __init__(self): 
        """__init__(self) -> ArClientBase"""
        this = _ArNetworkingPy.new_ArClientBase()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientBase
    __del__ = lambda self : None;
    def setRobotName(self, *args):
        """
        setRobotName(self, char name, bool debugLogging = False, int robotId = 0)
        setRobotName(self, char name, bool debugLogging = False)
        setRobotName(self, char name)
        """
        return _ArNetworkingPy.ArClientBase_setRobotName(self, *args)

    def getRobotName(self):
        """getRobotName(self) -> char"""
        return _ArNetworkingPy.ArClientBase_getRobotName(self)

    def getLogPrefix(self):
        """getLogPrefix(self) -> char"""
        return _ArNetworkingPy.ArClientBase_getLogPrefix(self)

    def getDebugLogging(self):
        """getDebugLogging(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getDebugLogging(self)

    def blockingConnect(self, *args):
        """
        blockingConnect(self, char host, int port, bool log = True, char user = None, 
            char password = None, char openOnIP = None) -> bool
        blockingConnect(self, char host, int port, bool log = True, char user = None, 
            char password = None) -> bool
        blockingConnect(self, char host, int port, bool log = True, char user = None) -> bool
        blockingConnect(self, char host, int port, bool log = True) -> bool
        blockingConnect(self, char host, int port) -> bool
        """
        return _ArNetworkingPy.ArClientBase_blockingConnect(self, *args)

    def disconnect(self):
        """disconnect(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_disconnect(self)

    def disconnectSoon(self):
        """disconnectSoon(self)"""
        return _ArNetworkingPy.ArClientBase_disconnectSoon(self)

    def isConnected(self):
        """isConnected(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isConnected(self)

    def wasRejected(self):
        """wasRejected(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_wasRejected(self)

    def getState(self):
        """getState(self) -> ClientState"""
        return _ArNetworkingPy.ArClientBase_getState(self)

    def addHandler(self, *args):
        """addHandler(self, char name, ArFunctor1<(p.ArNetPacket)> functor) -> bool"""
        return _ArNetworkingPy.ArClientBase_addHandler(self, *args)

    def remHandler(self, *args):
        """remHandler(self, char name, ArFunctor1<(p.ArNetPacket)> functor) -> bool"""
        return _ArNetworkingPy.ArClientBase_remHandler(self, *args)

    def request(self, *args):
        """
        request(self, char name, long mSec, ArNetPacket packet = None) -> bool
        request(self, char name, long mSec) -> bool
        """
        return _ArNetworkingPy.ArClientBase_request(self, *args)

    def requestStop(self, *args):
        """requestStop(self, char name) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestStop(self, *args)

    def requestOnce(self, *args):
        """
        requestOnce(self, char name, ArNetPacket packet = None, bool quiet = False) -> bool
        requestOnce(self, char name, ArNetPacket packet = None) -> bool
        requestOnce(self, char name) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnce(self, *args)

    def requestOnceUdp(self, *args):
        """
        requestOnceUdp(self, char name, ArNetPacket packet = None, bool quiet = False) -> bool
        requestOnceUdp(self, char name, ArNetPacket packet = None) -> bool
        requestOnceUdp(self, char name) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceUdp(self, *args)

    def requestOnceWithString(self, *args):
        """requestOnceWithString(self, char name, char str) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestOnceWithString(self, *args)

    def dataExists(self, *args):
        """dataExists(self, char name) -> bool"""
        return _ArNetworkingPy.ArClientBase_dataExists(self, *args)

    def getHost(self):
        """getHost(self) -> char"""
        return _ArNetworkingPy.ArClientBase_getHost(self)

    def setServerKey(self, *args):
        """
        setServerKey(self, char serverKey, bool log = True)
        setServerKey(self, char serverKey)
        """
        return _ArNetworkingPy.ArClientBase_setServerKey(self, *args)

    def enforceProtocolVersion(self, *args):
        """
        enforceProtocolVersion(self, char protocolVersion, bool log = True)
        enforceProtocolVersion(self, char protocolVersion)
        """
        return _ArNetworkingPy.ArClientBase_enforceProtocolVersion(self, *args)

    def enforceType(self, *args):
        """
        enforceType(self, Type type, bool log = True)
        enforceType(self, Type type)
        """
        return _ArNetworkingPy.ArClientBase_enforceType(self, *args)

    def getLastPacketReceived(self):
        """getLastPacketReceived(self) -> ArTime"""
        return _ArNetworkingPy.ArClientBase_getLastPacketReceived(self)

    def setBackupTimeout(self, *args):
        """setBackupTimeout(self, double timeoutInMins)"""
        return _ArNetworkingPy.ArClientBase_setBackupTimeout(self, *args)

    def run(self):
        """run(self)"""
        return _ArNetworkingPy.ArClientBase_run(self)

    def runAsync(self):
        """runAsync(self)"""
        return _ArNetworkingPy.ArClientBase_runAsync(self)

    def stopRunning(self):
        """stopRunning(self)"""
        return _ArNetworkingPy.ArClientBase_stopRunning(self)

    def isStopped(self):
        """isStopped(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isStopped(self)

    def logDataList(self):
        """logDataList(self)"""
        return _ArNetworkingPy.ArClientBase_logDataList(self)

    def addCycleCallback(self, *args):
        """addCycleCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_addCycleCallback(self, *args)

    def remCycleCallback(self, *args):
        """remCycleCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remCycleCallback(self, *args)

    def sendPacketTcp(self, *args):
        """sendPacketTcp(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientBase_sendPacketTcp(self, *args)

    def sendPacketUdp(self, *args):
        """sendPacketUdp(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArClientBase_sendPacketUdp(self, *args)

    def setConnectTimeoutTime(self, *args):
        """setConnectTimeoutTime(self, int sec)"""
        return _ArNetworkingPy.ArClientBase_setConnectTimeoutTime(self, *args)

    def getConnectTimeoutTime(self):
        """getConnectTimeoutTime(self) -> int"""
        return _ArNetworkingPy.ArClientBase_getConnectTimeoutTime(self)

    def logTracking(self, *args):
        """logTracking(self, bool terse)"""
        return _ArNetworkingPy.ArClientBase_logTracking(self, *args)

    def resetTracking(self):
        """resetTracking(self)"""
        return _ArNetworkingPy.ArClientBase_resetTracking(self)

    def addServerShutdownCB(self, *args):
        """
        addServerShutdownCB(self, ArFunctor functor, Pos position = LAST)
        addServerShutdownCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientBase_addServerShutdownCB(self, *args)

    def remServerShutdownCB(self, *args):
        """remServerShutdownCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remServerShutdownCB(self, *args)

    def addDisconnectOnErrorCB(self, *args):
        """
        addDisconnectOnErrorCB(self, ArFunctor functor, Pos position = LAST)
        addDisconnectOnErrorCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientBase_addDisconnectOnErrorCB(self, *args)

    def remDisconnectOnErrorCB(self, *args):
        """remDisconnectOnErrorCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientBase_remDisconnectOnErrorCB(self, *args)

    def loopOnce(self):
        """loopOnce(self)"""
        return _ArNetworkingPy.ArClientBase_loopOnce(self)

    def processPacket(self, *args):
        """processPacket(self, ArNetPacket packet, bool tcp)"""
        return _ArNetworkingPy.ArClientBase_processPacket(self, *args)

    def processPacketUdp(self, *args):
        """processPacketUdp(self, ArNetPacket packet, sockaddr_in sin)"""
        return _ArNetworkingPy.ArClientBase_processPacketUdp(self, *args)

    def setTcpOnlyFromServer(self):
        """setTcpOnlyFromServer(self)"""
        return _ArNetworkingPy.ArClientBase_setTcpOnlyFromServer(self)

    def setTcpOnlyToServer(self):
        """setTcpOnlyToServer(self)"""
        return _ArNetworkingPy.ArClientBase_setTcpOnlyToServer(self)

    def isTcpOnlyFromServer(self):
        """isTcpOnlyFromServer(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isTcpOnlyFromServer(self)

    def isTcpOnlyToServer(self):
        """isTcpOnlyToServer(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_isTcpOnlyToServer(self)

    def getClientKey(self, *args):
        """getClientKey(self, unsigned char key)"""
        return _ArNetworkingPy.ArClientBase_getClientKey(self, *args)

    def startNonBlockingDisconnect(self):
        """startNonBlockingDisconnect(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_startNonBlockingDisconnect(self)

    def finishNonBlockingDisconnect(self):
        """finishNonBlockingDisconnect(self)"""
        return _ArNetworkingPy.ArClientBase_finishNonBlockingDisconnect(self)

    def getName(self, *args):
        """
        getName(self, ArNetPacket packet, bool internalCall = False) -> char
        getName(self, ArNetPacket packet) -> char
        getName(self, unsigned int command, bool internalCall = False) -> char
        getName(self, unsigned int command) -> char
        """
        return _ArNetworkingPy.ArClientBase_getName(self, *args)

    def runThread(self, *args):
        """runThread(self, void arg) -> void"""
        return _ArNetworkingPy.ArClientBase_runThread(self, *args)

    def getTcpAddr(self):
        """getTcpAddr(self) -> in_addr"""
        return _ArNetworkingPy.ArClientBase_getTcpAddr(self)

    def internalBlockingConnect(self, *args):
        """
        internalBlockingConnect(self, char host, int port, bool log, char user, char password, 
            ArSocket tcpSocket, char openOnIP = None) -> bool
        internalBlockingConnect(self, char host, int port, bool log, char user, char password, 
            ArSocket tcpSocket) -> bool
        """
        return _ArNetworkingPy.ArClientBase_internalBlockingConnect(self, *args)

    def internalNonBlockingConnectStart(self, *args):
        """
        internalNonBlockingConnectStart(self, char host, int port, bool log, char user, char password, 
            ArSocket tcpSocket, char openOnIP = None) -> NonBlockingConnectReturn
        internalNonBlockingConnectStart(self, char host, int port, bool log, char user, char password, 
            ArSocket tcpSocket) -> NonBlockingConnectReturn
        """
        return _ArNetworkingPy.ArClientBase_internalNonBlockingConnectStart(self, *args)

    def internalNonBlockingConnectContinue(self):
        """internalNonBlockingConnectContinue(self) -> NonBlockingConnectReturn"""
        return _ArNetworkingPy.ArClientBase_internalNonBlockingConnectContinue(self)

    def getTcpSocket(self):
        """getTcpSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArClientBase_getTcpSocket(self)

    def getUdpSocket(self):
        """getUdpSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArClientBase_getUdpSocket(self)

    def getDataMap(self):
        """getDataMap(self) -> std::map<(unsigned int,p.ArClientData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArClientData)>)>)>"""
        return _ArNetworkingPy.ArClientBase_getDataMap(self)

    def findCommandFromName(self, *args):
        """findCommandFromName(self, char name) -> unsigned int"""
        return _ArNetworkingPy.ArClientBase_findCommandFromName(self, *args)

    def requestByCommand(self, *args):
        """
        requestByCommand(self, unsigned int command, long mSec, ArNetPacket packet = None) -> bool
        requestByCommand(self, unsigned int command, long mSec) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestByCommand(self, *args)

    def requestStopByCommand(self, *args):
        """requestStopByCommand(self, unsigned int command) -> bool"""
        return _ArNetworkingPy.ArClientBase_requestStopByCommand(self, *args)

    def requestOnceByCommand(self, *args):
        """
        requestOnceByCommand(self, unsigned int command, ArNetPacket packet = None) -> bool
        requestOnceByCommand(self, unsigned int command) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceByCommand(self, *args)

    def requestOnceByCommandUdp(self, *args):
        """
        requestOnceByCommandUdp(self, unsigned int command, ArNetPacket packet = None) -> bool
        requestOnceByCommandUdp(self, unsigned int command) -> bool
        """
        return _ArNetworkingPy.ArClientBase_requestOnceByCommandUdp(self, *args)

    def getReceivedDataList(self):
        """getReceivedDataList(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedDataList(self)

    def getReceivedArgRetList(self):
        """getReceivedArgRetList(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedArgRetList(self)

    def getReceivedGroupAndFlagsList(self):
        """getReceivedGroupAndFlagsList(self) -> bool"""
        return _ArNetworkingPy.ArClientBase_getReceivedGroupAndFlagsList(self)

    def getRejected(self):
        """getRejected(self) -> int"""
        return _ArNetworkingPy.ArClientBase_getRejected(self)

    def getRejectedString(self):
        """getRejectedString(self) -> char"""
        return _ArNetworkingPy.ArClientBase_getRejectedString(self)

ArClientBase_swigregister = _ArNetworkingPy.ArClientBase_swigregister
ArClientBase_swigregister(ArClientBase)

class ArClientCommands(_object):
    """Proxy of C++ ArClientCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientCommands, name)
    __repr__ = _swig_repr
    SHUTDOWN = _ArNetworkingPy.ArClientCommands_SHUTDOWN
    INTRODUCTION = _ArNetworkingPy.ArClientCommands_INTRODUCTION
    UDP_INTRODUCTION = _ArNetworkingPy.ArClientCommands_UDP_INTRODUCTION
    UDP_CONFIRMATION = _ArNetworkingPy.ArClientCommands_UDP_CONFIRMATION
    TCP_ONLY = _ArNetworkingPy.ArClientCommands_TCP_ONLY
    LIST = _ArNetworkingPy.ArClientCommands_LIST
    REQUEST = _ArNetworkingPy.ArClientCommands_REQUEST
    REQUESTSTOP = _ArNetworkingPy.ArClientCommands_REQUESTSTOP
    def __init__(self): 
        """__init__(self) -> ArClientCommands"""
        this = _ArNetworkingPy.new_ArClientCommands()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientCommands
    __del__ = lambda self : None;
ArClientCommands_swigregister = _ArNetworkingPy.ArClientCommands_swigregister
ArClientCommands_swigregister(ArClientCommands)

class ArClientData(_object):
    """Proxy of C++ ArClientData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientData, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor1<(p.ArNetPacket)> functor) -> ArClientData
        """
        this = _ArNetworkingPy.new_ArClientData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientData
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> char"""
        return _ArNetworkingPy.ArClientData_getName(self)

    def getDescription(self):
        """getDescription(self) -> char"""
        return _ArNetworkingPy.ArClientData_getDescription(self)

    def getCommand(self):
        """getCommand(self) -> unsigned int"""
        return _ArNetworkingPy.ArClientData_getCommand(self)

    def getArgumentDescription(self):
        """getArgumentDescription(self) -> char"""
        return _ArNetworkingPy.ArClientData_getArgumentDescription(self)

    def getReturnDescription(self):
        """getReturnDescription(self) -> char"""
        return _ArNetworkingPy.ArClientData_getReturnDescription(self)

    def getCommandGroup(self):
        """getCommandGroup(self) -> char"""
        return _ArNetworkingPy.ArClientData_getCommandGroup(self)

    def hasDataFlag(self, *args):
        """hasDataFlag(self, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArClientData_hasDataFlag(self, *args)

    def getDataFlagsString(self):
        """getDataFlagsString(self) -> char"""
        return _ArNetworkingPy.ArClientData_getDataFlagsString(self)

    def getFunctorList(self):
        """getFunctorList(self) -> std::list<(p.ArFunctor1<(p.ArNetPacket)>,std::allocator<(p.ArFunctor1<(p.ArNetPacket)>)>)>"""
        return _ArNetworkingPy.ArClientData_getFunctorList(self)

    def lockFunctorList(self):
        """lockFunctorList(self) -> int"""
        return _ArNetworkingPy.ArClientData_lockFunctorList(self)

    def tryLockFunctorList(self):
        """tryLockFunctorList(self) -> int"""
        return _ArNetworkingPy.ArClientData_tryLockFunctorList(self)

    def unlockFunctorList(self):
        """unlockFunctorList(self) -> int"""
        return _ArNetworkingPy.ArClientData_unlockFunctorList(self)

    def addFunctor(self, *args):
        """addFunctor(self, ArFunctor1<(p.ArNetPacket)> functor)"""
        return _ArNetworkingPy.ArClientData_addFunctor(self, *args)

    def remFunctor(self, *args):
        """remFunctor(self, ArFunctor1<(p.ArNetPacket)> functor)"""
        return _ArNetworkingPy.ArClientData_remFunctor(self, *args)

    def setArgRetDescs(self, *args):
        """setArgRetDescs(self, char argDesc, char retDesc)"""
        return _ArNetworkingPy.ArClientData_setArgRetDescs(self, *args)

    def setCommandGroup(self, *args):
        """setCommandGroup(self, char commandGroup)"""
        return _ArNetworkingPy.ArClientData_setCommandGroup(self, *args)

    def addDataFlags(self, *args):
        """addDataFlags(self, char dataFlags)"""
        return _ArNetworkingPy.ArClientData_addDataFlags(self, *args)

ArClientData_swigregister = _ArNetworkingPy.ArClientData_swigregister
ArClientData_swigregister(ArClientData)

class ArClientFileListerItem(_object):
    """Proxy of C++ ArClientFileListerItem class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileListerItem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileListerItem, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, time_t atime, time_t mtime, UByte4 size) -> ArClientFileListerItem
        __init__(self, ArClientFileListerItem item) -> ArClientFileListerItem
        """
        this = _ArNetworkingPy.new_ArClientFileListerItem(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileListerItem
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> char"""
        return _ArNetworkingPy.ArClientFileListerItem_getName(self)

    def getLastAccessedTime(self):
        """getLastAccessedTime(self) -> time_t"""
        return _ArNetworkingPy.ArClientFileListerItem_getLastAccessedTime(self)

    def getLastModifiedTime(self):
        """getLastModifiedTime(self) -> time_t"""
        return _ArNetworkingPy.ArClientFileListerItem_getLastModifiedTime(self)

    def getSize(self):
        """getSize(self) -> UByte4"""
        return _ArNetworkingPy.ArClientFileListerItem_getSize(self)

ArClientFileListerItem_swigregister = _ArNetworkingPy.ArClientFileListerItem_swigregister
ArClientFileListerItem_swigregister(ArClientFileListerItem)

class ArClientFileLister(_object):
    """Proxy of C++ ArClientFileLister class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileLister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileLister, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientFileLister"""
        this = _ArNetworkingPy.new_ArClientFileLister(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileLister
    __del__ = lambda self : None;
    def isAvailable(self):
        """isAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientFileLister_isAvailable(self)

    def changeToTopDir(self):
        """changeToTopDir(self)"""
        return _ArNetworkingPy.ArClientFileLister_changeToTopDir(self)

    def changeToDir(self, *args):
        """changeToDir(self, char dir)"""
        return _ArNetworkingPy.ArClientFileLister_changeToDir(self, *args)

    def upOneDir(self):
        """upOneDir(self)"""
        return _ArNetworkingPy.ArClientFileLister_upOneDir(self)

    def changeToAbsDir(self, *args):
        """changeToAbsDir(self, char dir)"""
        return _ArNetworkingPy.ArClientFileLister_changeToAbsDir(self, *args)

    def getCurrentDir(self):
        """getCurrentDir(self) -> char"""
        return _ArNetworkingPy.ArClientFileLister_getCurrentDir(self)

    def getWaitingForDir(self):
        """getWaitingForDir(self) -> char"""
        return _ArNetworkingPy.ArClientFileLister_getWaitingForDir(self)

    def getDirectories(self):
        """getDirectories(self) -> std::list<(ArClientFileListerItem,std::allocator<(ArClientFileListerItem)>)>"""
        return _ArNetworkingPy.ArClientFileLister_getDirectories(self)

    def getFiles(self):
        """getFiles(self) -> std::list<(ArClientFileListerItem,std::allocator<(ArClientFileListerItem)>)>"""
        return _ArNetworkingPy.ArClientFileLister_getFiles(self)

    def addUpdatedCallback(self, *args):
        """
        addUpdatedCallback(self, ArFunctor1_Int functor, Pos position = LAST)
        addUpdatedCallback(self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileLister_addUpdatedCallback(self, *args)

    def remUpdatedCallback(self, *args):
        """remUpdatedCallback(self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileLister_remUpdatedCallback(self, *args)

    def getLastUpdated(self):
        """getLastUpdated(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileLister_getLastUpdated(self)

    def getLastRequested(self):
        """getLastRequested(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileLister_getLastRequested(self)

    def log(self, *args):
        """log(self, bool withTimes)"""
        return _ArNetworkingPy.ArClientFileLister_log(self, *args)

ArClientFileLister_swigregister = _ArNetworkingPy.ArClientFileLister_swigregister
ArClientFileLister_swigregister(ArClientFileLister)

class ArClientFileToClient(_object):
    """Proxy of C++ ArClientFileToClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileToClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileToClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientFileToClient"""
        this = _ArNetworkingPy.new_ArClientFileToClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileToClient
    __del__ = lambda self : None;
    def isAvailable(self):
        """isAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isAvailable(self)

    def isAvailableSetTimestamp(self):
        """isAvailableSetTimestamp(self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isAvailableSetTimestamp(self)

    def getFileFromDirectory(self, *args):
        """
        getFileFromDirectory(self, char directory, char fileName, char clientFileName, 
            bool isSetTimestamp = False) -> bool
        getFileFromDirectory(self, char directory, char fileName, char clientFileName) -> bool
        """
        return _ArNetworkingPy.ArClientFileToClient_getFileFromDirectory(self, *args)

    def cancelGet(self):
        """cancelGet(self)"""
        return _ArNetworkingPy.ArClientFileToClient_cancelGet(self)

    def isWaitingForFile(self):
        """isWaitingForFile(self) -> bool"""
        return _ArNetworkingPy.ArClientFileToClient_isWaitingForFile(self)

    def getDirectory(self):
        """getDirectory(self) -> char"""
        return _ArNetworkingPy.ArClientFileToClient_getDirectory(self)

    def getFileName(self):
        """getFileName(self) -> char"""
        return _ArNetworkingPy.ArClientFileToClient_getFileName(self)

    def getClientFileName(self):
        """getClientFileName(self) -> char"""
        return _ArNetworkingPy.ArClientFileToClient_getClientFileName(self)

    def addFileReceivedCallback(self, *args):
        """
        addFileReceivedCallback(self, ArFunctor1_Int functor, Pos position = LAST)
        addFileReceivedCallback(self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileToClient_addFileReceivedCallback(self, *args)

    def remFileReceivedCallback(self, *args):
        """remFileReceivedCallback(self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileToClient_remFileReceivedCallback(self, *args)

    def getLastReceived(self):
        """getLastReceived(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileToClient_getLastReceived(self)

    def getLastRequested(self):
        """getLastRequested(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileToClient_getLastRequested(self)

ArClientFileToClient_swigregister = _ArNetworkingPy.ArClientFileToClient_swigregister
ArClientFileToClient_swigregister(ArClientFileToClient)

class ArClientFileFromClient(_object):
    """Proxy of C++ ArClientFileFromClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientFileFromClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientFileFromClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientFileFromClient"""
        this = _ArNetworkingPy.new_ArClientFileFromClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientFileFromClient
    __del__ = lambda self : None;
    def isAvailable(self):
        """isAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailable(self)

    def isAvailableSlow(self):
        """isAvailableSlow(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableSlow(self)

    def isAvailableFast(self):
        """isAvailableFast(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableFast(self)

    def isAvailableSetTimestamp(self):
        """isAvailableSetTimestamp(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isAvailableSetTimestamp(self)

    SPEED_AUTO = _ArNetworkingPy.ArClientFileFromClient_SPEED_AUTO
    SPEED_FAST = _ArNetworkingPy.ArClientFileFromClient_SPEED_FAST
    SPEED_SLOW = _ArNetworkingPy.ArClientFileFromClient_SPEED_SLOW
    def putFileToDirectory(self, *args):
        """
        putFileToDirectory(self, char directory, char fileName, char clientFileName, 
            SendSpeed sendSpeed = SPEED_AUTO, bool isSetTimestamp = False) -> bool
        putFileToDirectory(self, char directory, char fileName, char clientFileName, 
            SendSpeed sendSpeed = SPEED_AUTO) -> bool
        putFileToDirectory(self, char directory, char fileName, char clientFileName) -> bool
        """
        return _ArNetworkingPy.ArClientFileFromClient_putFileToDirectory(self, *args)

    def cancelPut(self):
        """cancelPut(self)"""
        return _ArNetworkingPy.ArClientFileFromClient_cancelPut(self)

    def isWaitingForReturn(self):
        """isWaitingForReturn(self) -> bool"""
        return _ArNetworkingPy.ArClientFileFromClient_isWaitingForReturn(self)

    def getDirectory(self):
        """getDirectory(self) -> char"""
        return _ArNetworkingPy.ArClientFileFromClient_getDirectory(self)

    def getFileName(self):
        """getFileName(self) -> char"""
        return _ArNetworkingPy.ArClientFileFromClient_getFileName(self)

    def getClientFileName(self):
        """getClientFileName(self) -> char"""
        return _ArNetworkingPy.ArClientFileFromClient_getClientFileName(self)

    def addFileSentCallback(self, *args):
        """
        addFileSentCallback(self, ArFunctor1_Int functor, Pos position = LAST)
        addFileSentCallback(self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientFileFromClient_addFileSentCallback(self, *args)

    def remFileSentCallback(self, *args):
        """remFileSentCallback(self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientFileFromClient_remFileSentCallback(self, *args)

    def getLastCompletedSend(self):
        """getLastCompletedSend(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileFromClient_getLastCompletedSend(self)

    def getLastStartedSend(self):
        """getLastStartedSend(self) -> ArTime"""
        return _ArNetworkingPy.ArClientFileFromClient_getLastStartedSend(self)

ArClientFileFromClient_swigregister = _ArNetworkingPy.ArClientFileFromClient_swigregister
ArClientFileFromClient_swigregister(ArClientFileFromClient)

class ArClientDeleteFileOnServer(_object):
    """Proxy of C++ ArClientDeleteFileOnServer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientDeleteFileOnServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientDeleteFileOnServer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientDeleteFileOnServer"""
        this = _ArNetworkingPy.new_ArClientDeleteFileOnServer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientDeleteFileOnServer
    __del__ = lambda self : None;
    def isAvailable(self):
        """isAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_isAvailable(self)

    def deleteFileFromDirectory(self, *args):
        """deleteFileFromDirectory(self, char directory, char fileName) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_deleteFileFromDirectory(self, *args)

    def isWaitingForReturn(self):
        """isWaitingForReturn(self) -> bool"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_isWaitingForReturn(self)

    def getDirectory(self):
        """getDirectory(self) -> char"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getDirectory(self)

    def getFileName(self):
        """getFileName(self) -> char"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getFileName(self)

    def addFileDeletedCallback(self, *args):
        """
        addFileDeletedCallback(self, ArFunctor1_Int functor, Pos position = LAST)
        addFileDeletedCallback(self, ArFunctor1_Int functor)
        """
        return _ArNetworkingPy.ArClientDeleteFileOnServer_addFileDeletedCallback(self, *args)

    def remFileDeletedCallback(self, *args):
        """remFileDeletedCallback(self, ArFunctor1_Int functor)"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_remFileDeletedCallback(self, *args)

    def getLastCompletedSend(self):
        """getLastCompletedSend(self) -> ArTime"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getLastCompletedSend(self)

    def getLastStartedSend(self):
        """getLastStartedSend(self) -> ArTime"""
        return _ArNetworkingPy.ArClientDeleteFileOnServer_getLastStartedSend(self)

ArClientDeleteFileOnServer_swigregister = _ArNetworkingPy.ArClientDeleteFileOnServer_swigregister
ArClientDeleteFileOnServer_swigregister(ArClientDeleteFileOnServer)

class ArClientHandlerConfig(_object):
    """Proxy of C++ ArClientHandlerConfig class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientHandlerConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientHandlerConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArClientBase client, bool ignoreBounds = False, char robotName = None, 
            char logPrefix = None) -> ArClientHandlerConfig
        __init__(self, ArClientBase client, bool ignoreBounds = False, char robotName = None) -> ArClientHandlerConfig
        __init__(self, ArClientBase client, bool ignoreBounds = False) -> ArClientHandlerConfig
        __init__(self, ArClientBase client) -> ArClientHandlerConfig
        """
        this = _ArNetworkingPy.new_ArClientHandlerConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientHandlerConfig
    __del__ = lambda self : None;
    def requestConfigFromServer(self):
        """requestConfigFromServer(self)"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestConfigFromServer(self)

    def reloadConfigOnServer(self):
        """reloadConfigOnServer(self)"""
        return _ArNetworkingPy.ArClientHandlerConfig_reloadConfigOnServer(self)

    def getConfigCopy(self):
        """getConfigCopy(self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getConfigCopy(self)

    def addGotConfigCB(self, *args):
        """
        addGotConfigCB(self, ArFunctor functor, Pos position = LAST)
        addGotConfigCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addGotConfigCB(self, *args)

    def remGotConfigCB(self, *args):
        """remGotConfigCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remGotConfigCB(self, *args)

    def addSaveConfigSucceededCB(self, *args):
        """
        addSaveConfigSucceededCB(self, ArFunctor functor, Pos position = LAST)
        addSaveConfigSucceededCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addSaveConfigSucceededCB(self, *args)

    def remSaveConfigSucceededCB(self, *args):
        """remSaveConfigSucceededCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remSaveConfigSucceededCB(self, *args)

    def addSaveConfigFailedCB(self, *args):
        """
        addSaveConfigFailedCB(self, ArFunctor1_CString functor, Pos position = LAST)
        addSaveConfigFailedCB(self, ArFunctor1_CString functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addSaveConfigFailedCB(self, *args)

    def remSaveConfigFailedCB(self, *args):
        """remSaveConfigFailedCB(self, ArFunctor1_CString functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remSaveConfigFailedCB(self, *args)

    def haveGottenConfig(self):
        """haveGottenConfig(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveGottenConfig(self)

    def saveConfigToServer(self, *args):
        """
        saveConfigToServer(self)
        saveConfigToServer(self, ArConfig config, std::set<(std::string,ArStrCaseCmpOp,std::allocator<(std::string)>)> ignoreTheseSections = None)
        saveConfigToServer(self, ArConfig config)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_saveConfigToServer(self, *args)

    def haveRequestedDefaults(self):
        """haveRequestedDefaults(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveRequestedDefaults(self)

    def haveGottenDefaults(self):
        """haveGottenDefaults(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveGottenDefaults(self)

    def canRequestDefaults(self):
        """canRequestDefaults(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_canRequestDefaults(self)

    def requestDefaultConfigFromServer(self):
        """requestDefaultConfigFromServer(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestDefaultConfigFromServer(self)

    def getDefaultConfig(self):
        """getDefaultConfig(self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getDefaultConfig(self)

    def requestConfigDefaults(self):
        """requestConfigDefaults(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestConfigDefaults(self)

    def requestSectionDefaults(self, *args):
        """requestSectionDefaults(self, char section) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestSectionDefaults(self, *args)

    def addGotConfigDefaultsCB(self, *args):
        """
        addGotConfigDefaultsCB(self, ArFunctor functor, Pos position = LAST)
        addGotConfigDefaultsCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addGotConfigDefaultsCB(self, *args)

    def remGotConfigDefaultsCB(self, *args):
        """remGotConfigDefaultsCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remGotConfigDefaultsCB(self, *args)

    def isLastEditablePriorityAvailable(self):
        """isLastEditablePriorityAvailable(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_isLastEditablePriorityAvailable(self)

    def requestLastEditablePriorityFromServer(self):
        """requestLastEditablePriorityFromServer(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_requestLastEditablePriorityFromServer(self)

    def haveGottenLastEditablePriority(self):
        """haveGottenLastEditablePriority(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerConfig_haveGottenLastEditablePriority(self)

    def getLastEditablePriority(self):
        """getLastEditablePriority(self) -> Priority"""
        return _ArNetworkingPy.ArClientHandlerConfig_getLastEditablePriority(self)

    def addGotLastEditablePriorityCB(self, *args):
        """
        addGotLastEditablePriorityCB(self, ArFunctor functor, int position = 50)
        addGotLastEditablePriorityCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArClientHandlerConfig_addGotLastEditablePriorityCB(self, *args)

    def remGotLastEditablePriorityCB(self, *args):
        """remGotLastEditablePriorityCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArClientHandlerConfig_remGotLastEditablePriorityCB(self, *args)

    def getConfig(self):
        """getConfig(self) -> ArConfig"""
        return _ArNetworkingPy.ArClientHandlerConfig_getConfig(self)

    def lock(self):
        """lock(self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_lock(self)

    def tryLock(self):
        """tryLock(self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_tryLock(self)

    def unlock(self):
        """unlock(self) -> int"""
        return _ArNetworkingPy.ArClientHandlerConfig_unlock(self)

    def setQuiet(self, *args):
        """setQuiet(self, bool isQuiet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_setQuiet(self, *args)

    def handleGetConfigBySectionsV4(self, *args):
        """handleGetConfigBySectionsV4(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigBySectionsV4(self, *args)

    def handleGetConfigBySectionsV3(self, *args):
        """handleGetConfigBySectionsV3(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigBySectionsV3(self, *args)

    def handleGetConfigBySectionsV2(self, *args):
        """handleGetConfigBySectionsV2(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigBySectionsV2(self, *args)

    def handleGetConfigBySections(self, *args):
        """handleGetConfigBySections(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigBySections(self, *args)

    def handleGetConfigSectionFlags(self, *args):
        """handleGetConfigSectionFlags(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigSectionFlags(self, *args)

    def handleGetConfig(self, *args):
        """handleGetConfig(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfig(self, *args)

    def handleSetConfig(self, *args):
        """handleSetConfig(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleSetConfig(self, *args)

    def handleSetConfigBySections(self, *args):
        """handleSetConfigBySections(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleSetConfigBySections(self, *args)

    def handleSetConfigBySectionsV2(self, *args):
        """handleSetConfigBySectionsV2(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleSetConfigBySectionsV2(self, *args)

    def handleGetConfigDefaults(self, *args):
        """handleGetConfigDefaults(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetConfigDefaults(self, *args)

    def handleGetLastEditablePriority(self, *args):
        """handleGetLastEditablePriority(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArClientHandlerConfig_handleGetLastEditablePriority(self, *args)

ArClientHandlerConfig_swigregister = _ArNetworkingPy.ArClientHandlerConfig_swigregister
ArClientHandlerConfig_swigregister(ArClientHandlerConfig)

class ArClientSimpleConnector(_object):
    """Proxy of C++ ArClientSimpleConnector class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientSimpleConnector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientSimpleConnector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArArgumentParser parser) -> ArClientSimpleConnector
        __init__(self, int argc) -> ArClientSimpleConnector
        __init__(self, ArArgumentBuilder arguments) -> ArClientSimpleConnector
        """
        this = _ArNetworkingPy.new_ArClientSimpleConnector(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientSimpleConnector
    __del__ = lambda self : None;
    def connectClient(self, *args):
        """
        connectClient(self, ArClientBase client, bool log = True) -> bool
        connectClient(self, ArClientBase client) -> bool
        """
        return _ArNetworkingPy.ArClientSimpleConnector_connectClient(self, *args)

    def parseArgs(self, *args):
        """
        parseArgs(self) -> bool
        parseArgs(self, ArArgumentParser parser) -> bool
        """
        return _ArNetworkingPy.ArClientSimpleConnector_parseArgs(self, *args)

    def logOptions(self):
        """logOptions(self)"""
        return _ArNetworkingPy.ArClientSimpleConnector_logOptions(self)

ArClientSimpleConnector_swigregister = _ArNetworkingPy.ArClientSimpleConnector_swigregister
ArClientSimpleConnector_swigregister(ArClientSimpleConnector)

class ArHybridForwarderVideo(AriaPy.ArCameraCollectionItem):
    """Proxy of C++ ArHybridForwarderVideo class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArHybridForwarderVideo, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArHybridForwarderVideo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArClientBase client) -> ArHybridForwarderVideo
        __init__(self, ArServerBase server, char hostname = "localhost", int port = 7070) -> ArHybridForwarderVideo
        __init__(self, ArServerBase server, char hostname = "localhost") -> ArHybridForwarderVideo
        __init__(self, ArServerBase server) -> ArHybridForwarderVideo
        """
        this = _ArNetworkingPy.new_ArHybridForwarderVideo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArHybridForwarderVideo
    __del__ = lambda self : None;
    def isForwardingVideo(self):
        """isForwardingVideo(self) -> bool"""
        return _ArNetworkingPy.ArHybridForwarderVideo_isForwardingVideo(self)

    def getCameraName(self):
        """getCameraName(self) -> char"""
        return _ArNetworkingPy.ArHybridForwarderVideo_getCameraName(self)

    def setCameraName(self, *args):
        """setCameraName(self, char cameraName)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_setCameraName(self, *args)

    def addToCameraCollection(self, *args):
        """addToCameraCollection(self, ArCameraCollection collection)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_addToCameraCollection(self, *args)

    def sendVideoSize(self, *args):
        """sendVideoSize(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_sendVideoSize(self, *args)

    def sendVideo(self, *args):
        """sendVideo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_sendVideo(self, *args)

    def receiveVideoSize(self, *args):
        """receiveVideoSize(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_receiveVideoSize(self, *args)

    def receiveVideo(self, *args):
        """receiveVideo(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_receiveVideo(self, *args)

    def clientCycleCallback(self):
        """clientCycleCallback(self)"""
        return _ArNetworkingPy.ArHybridForwarderVideo_clientCycleCallback(self)

    def setVideoRequestTime(self, *args):
        """
        setVideoRequestTime(self, int ms)
        setVideoRequestTime(self) -> int
        """
        return _ArNetworkingPy.ArHybridForwarderVideo_setVideoRequestTime(self, *args)

ArHybridForwarderVideo_swigregister = _ArNetworkingPy.ArHybridForwarderVideo_swigregister
ArHybridForwarderVideo_swigregister(ArHybridForwarderVideo)

class ArNetPacketReceiverTcp(_object):
    """Proxy of C++ ArNetPacketReceiverTcp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketReceiverTcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketReceiverTcp, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> ArNetPacketReceiverTcp"""
        this = _ArNetworkingPy.new_ArNetPacketReceiverTcp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketReceiverTcp
    __del__ = lambda self : None;
    def setSocket(self, *args):
        """setSocket(self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setSocket(self, *args)

    def getSocket(self):
        """getSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getSocket(self)

    def setProcessPacketCB(self, *args):
        """setProcessPacketCB(self, ArFunctor1<(p.ArNetPacket)> functor)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setProcessPacketCB(self, *args)

    def getProcessPacketCB(self):
        """getProcessPacketCB(self) -> ArFunctor1<(p.ArNetPacket)>"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getProcessPacketCB(self)

    def setLoggingPrefix(self, *args):
        """setLoggingPrefix(self, char loggingPrefix)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setLoggingPrefix(self, *args)

    def readData(self):
        """readData(self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_readData(self)

    def setQuiet(self, *args):
        """setQuiet(self, bool quiet)"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_setQuiet(self, *args)

    def getQuiet(self):
        """getQuiet(self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverTcp_getQuiet(self)

ArNetPacketReceiverTcp_swigregister = _ArNetworkingPy.ArNetPacketReceiverTcp_swigregister
ArNetPacketReceiverTcp_swigregister(ArNetPacketReceiverTcp)

class ArNetPacketReceiverUdp(_object):
    """Proxy of C++ ArNetPacketReceiverUdp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketReceiverUdp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketReceiverUdp, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> ArNetPacketReceiverUdp"""
        this = _ArNetworkingPy.new_ArNetPacketReceiverUdp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketReceiverUdp
    __del__ = lambda self : None;
    def setSocket(self, *args):
        """setSocket(self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_setSocket(self, *args)

    def getSocket(self):
        """getSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_getSocket(self)

    def setProcessPacketCB(self, *args):
        """setProcessPacketCB(self, ArFunctor2<(p.ArNetPacket,p.sockaddr_in)> functor)"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_setProcessPacketCB(self, *args)

    def getProcessPacketCB(self):
        """getProcessPacketCB(self) -> ArFunctor2<(p.ArNetPacket,p.sockaddr_in)>"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_getProcessPacketCB(self)

    def readData(self):
        """readData(self) -> bool"""
        return _ArNetworkingPy.ArNetPacketReceiverUdp_readData(self)

ArNetPacketReceiverUdp_swigregister = _ArNetworkingPy.ArNetPacketReceiverUdp_swigregister
ArNetPacketReceiverUdp_swigregister(ArNetPacketReceiverUdp)

class ArNetPacketSenderTcp(_object):
    """Proxy of C++ ArNetPacketSenderTcp class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArNetPacketSenderTcp, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArNetPacketSenderTcp, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> ArNetPacketSenderTcp"""
        this = _ArNetworkingPy.new_ArNetPacketSenderTcp()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArNetPacketSenderTcp
    __del__ = lambda self : None;
    def setSocket(self, *args):
        """setSocket(self, ArSocket socket)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setSocket(self, *args)

    def getSocket(self):
        """getSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_getSocket(self)

    def setBackupTimeout(self, *args):
        """setBackupTimeout(self, double connectionTimeoutInMins)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setBackupTimeout(self, *args)

    def setDebugLogging(self, *args):
        """setDebugLogging(self, bool debugLogging)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setDebugLogging(self, *args)

    def setLoggingPrefix(self, *args):
        """setLoggingPrefix(self, char prefix)"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_setLoggingPrefix(self, *args)

    def sendPacket(self, *args):
        """
        sendPacket(self, ArNetPacket packet, char loggingString = "")
        sendPacket(self, ArNetPacket packet)
        """
        return _ArNetworkingPy.ArNetPacketSenderTcp_sendPacket(self, *args)

    def sendData(self):
        """sendData(self) -> bool"""
        return _ArNetworkingPy.ArNetPacketSenderTcp_sendData(self)

ArNetPacketSenderTcp_swigregister = _ArNetworkingPy.ArNetPacketSenderTcp_swigregister
ArNetPacketSenderTcp_swigregister(ArNetPacketSenderTcp)

class ArServerClient(_object):
    """Proxy of C++ ArServerClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClient, name)
    __repr__ = _swig_repr
    STATE_SENT_INTRO = _ArNetworkingPy.ArServerClient_STATE_SENT_INTRO
    STATE_REJECTED = _ArNetworkingPy.ArServerClient_STATE_REJECTED
    STATE_CONNECTED = _ArNetworkingPy.ArServerClient_STATE_CONNECTED
    STATE_DISCONNECTED = _ArNetworkingPy.ArServerClient_STATE_DISCONNECTED
    def __init__(self, *args): 
        """
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0, 
            char rejectingString = "", 
            bool debugLogging = False, 
            char serverClientName = "ArServerBase_unknown", 
            bool logPasswordFailureVerbosely = False, 
            bool allowSlowPackets = True, bool allowIdlePackets = True, 
            char enforceProtocolVersion = "", 
            Type enforceType = TYPE_UNSPECIFIED) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0, 
            char rejectingString = "", 
            bool debugLogging = False, 
            char serverClientName = "ArServerBase_unknown", 
            bool logPasswordFailureVerbosely = False, 
            bool allowSlowPackets = True, bool allowIdlePackets = True, 
            char enforceProtocolVersion = "") -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0, 
            char rejectingString = "", 
            bool debugLogging = False, 
            char serverClientName = "ArServerBase_unknown", 
            bool logPasswordFailureVerbosely = False, 
            bool allowSlowPackets = True, bool allowIdlePackets = True) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0, 
            char rejectingString = "", 
            bool debugLogging = False, 
            char serverClientName = "ArServerBase_unknown", 
            bool logPasswordFailureVerbosely = False, 
            bool allowSlowPackets = True) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0, 
            char rejectingString = "", 
            bool debugLogging = False, 
            char serverClientName = "ArServerBase_unknown", 
            bool logPasswordFailureVerbosely = False) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0, 
            char rejectingString = "", 
            bool debugLogging = False, 
            char serverClientName = "ArServerBase_unknown") -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0, 
            char rejectingString = "", 
            bool debugLogging = False) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0, 
            char rejectingString = "") -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None, 
            int rejecting = 0) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey, 
            ArServerUserInfo userInfo = None) -> ArServerClient
        __init__(self, ArSocket tcpSocket, unsigned int udpPort, long authKey, 
            long introKey, ArRetFunctor2<(bool,p.ArNetPacket,p.sockaddr_in)> sendUdpCallback, 
            std::map<(unsigned int,p.ArServerData,std::less<(unsigned int)>,std::allocator<(std::pair<(q(const).unsigned int,p.ArServerData)>)>)> dataMap, 
            char passwordKey, 
            char serverKey) -> ArServerClient
        """
        this = _ArNetworkingPy.new_ArServerClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClient
    __del__ = lambda self : None;
    def tcpCallback(self):
        """tcpCallback(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_tcpCallback(self)

    def slowPacketCallback(self):
        """slowPacketCallback(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_slowPacketCallback(self)

    def idlePacketCallback(self):
        """idlePacketCallback(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_idlePacketCallback(self)

    def setBackupTimeout(self, *args):
        """setBackupTimeout(self, double timeoutInMins)"""
        return _ArNetworkingPy.ArServerClient_setBackupTimeout(self, *args)

    def processPacket(self, *args):
        """
        processPacket(self, ArNetPacket packet, bool tcp = True)
        processPacket(self, ArNetPacket packet)
        """
        return _ArNetworkingPy.ArServerClient_processPacket(self, *args)

    def sendPacketTcp(self, *args):
        """sendPacketTcp(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerClient_sendPacketTcp(self, *args)

    def sendPacketUdp(self, *args):
        """sendPacketUdp(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerClient_sendPacketUdp(self, *args)

    def hasGroupAccess(self, *args):
        """hasGroupAccess(self, char group) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasGroupAccess(self, *args)

    def broadcastPacketTcp(self, *args):
        """broadcastPacketTcp(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClient_broadcastPacketTcp(self, *args)

    def broadcastPacketUdp(self, *args):
        """broadcastPacketUdp(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClient_broadcastPacketUdp(self, *args)

    def logTracking(self, *args):
        """logTracking(self, bool terse)"""
        return _ArNetworkingPy.ArServerClient_logTracking(self, *args)

    def resetTracking(self):
        """resetTracking(self)"""
        return _ArNetworkingPy.ArServerClient_resetTracking(self)

    def getIPString(self):
        """getIPString(self) -> char"""
        return _ArNetworkingPy.ArServerClient_getIPString(self)

    def getIdentifier(self):
        """getIdentifier(self) -> ArServerClientIdentifier"""
        return _ArNetworkingPy.ArServerClient_getIdentifier(self)

    def setIdentifier(self, *args):
        """setIdentifier(self, ArServerClientIdentifier identifier)"""
        return _ArNetworkingPy.ArServerClient_setIdentifier(self, *args)

    def shutdown(self):
        """shutdown(self)"""
        return _ArNetworkingPy.ArServerClient_shutdown(self)

    def setUdpAddress(self, *args):
        """setUdpAddress(self, sockaddr_in sin)"""
        return _ArNetworkingPy.ArServerClient_setUdpAddress(self, *args)

    def getUdpAddress(self):
        """getUdpAddress(self) -> sockaddr_in"""
        return _ArNetworkingPy.ArServerClient_getUdpAddress(self)

    def getAuthKey(self):
        """getAuthKey(self) -> long"""
        return _ArNetworkingPy.ArServerClient_getAuthKey(self)

    def processAuthPacket(self, *args):
        """processAuthPacket(self, ArNetPacket packet, sockaddr_in sin)"""
        return _ArNetworkingPy.ArServerClient_processAuthPacket(self, *args)

    def handleRequests(self):
        """handleRequests(self)"""
        return _ArNetworkingPy.ArServerClient_handleRequests(self)

    def getTcpSocket(self):
        """getTcpSocket(self) -> ArSocket"""
        return _ArNetworkingPy.ArServerClient_getTcpSocket(self)

    def forceDisconnect(self, *args):
        """forceDisconnect(self, bool quiet)"""
        return _ArNetworkingPy.ArServerClient_forceDisconnect(self, *args)

    def getFrequency(self, *args):
        """getFrequency(self, UByte2 command) -> long"""
        return _ArNetworkingPy.ArServerClient_getFrequency(self, *args)

    def useTcpOnly(self):
        """useTcpOnly(self)"""
        return _ArNetworkingPy.ArServerClient_useTcpOnly(self)

    def isTcpOnly(self):
        """isTcpOnly(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_isTcpOnly(self)

    def getState(self):
        """getState(self) -> ServerState"""
        return _ArNetworkingPy.ArServerClient_getState(self)

    def hasSlowPackets(self):
        """hasSlowPackets(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasSlowPackets(self)

    def hasIdlePackets(self):
        """hasIdlePackets(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_hasIdlePackets(self)

    def startRequestTransaction(self):
        """startRequestTransaction(self)"""
        return _ArNetworkingPy.ArServerClient_startRequestTransaction(self)

    def endRequestTransaction(self):
        """endRequestTransaction(self) -> bool"""
        return _ArNetworkingPy.ArServerClient_endRequestTransaction(self)

    def getRequestTransactionCount(self):
        """getRequestTransactionCount(self) -> int"""
        return _ArNetworkingPy.ArServerClient_getRequestTransactionCount(self)

    def findCommandFromName(self, *args):
        """findCommandFromName(self, char commandName) -> unsigned int"""
        return _ArNetworkingPy.ArServerClient_findCommandFromName(self, *args)

    def getCreationTime(self):
        """getCreationTime(self) -> ArTime"""
        return _ArNetworkingPy.ArServerClient_getCreationTime(self)

ArServerClient_swigregister = _ArNetworkingPy.ArServerClient_swigregister
ArServerClient_swigregister(ArServerClient)

class ArServerClientIdentifier(_object):
    """Proxy of C++ ArServerClientIdentifier class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClientIdentifier, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClientIdentifier, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> ArServerClientIdentifier"""
        this = _ArNetworkingPy.new_ArServerClientIdentifier()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClientIdentifier
    __del__ = lambda self : None;
    def getIDString(self):
        """getIDString(self) -> char"""
        return _ArNetworkingPy.ArServerClientIdentifier_getIDString(self)

    def setConnectionID(self, *args):
        """setConnectionID(self, UByte4 idNum)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setConnectionID(self, *args)

    def getConnectionID(self):
        """getConnectionID(self) -> UByte4"""
        return _ArNetworkingPy.ArServerClientIdentifier_getConnectionID(self)

    def setSelfIdentifier(self, *args):
        """setSelfIdentifier(self, char selfIdentifier)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setSelfIdentifier(self, *args)

    def getSelfIdentifier(self):
        """getSelfIdentifier(self) -> char"""
        return _ArNetworkingPy.ArServerClientIdentifier_getSelfIdentifier(self)

    def setHereGoal(self, *args):
        """setHereGoal(self, char selfIdentifier)"""
        return _ArNetworkingPy.ArServerClientIdentifier_setHereGoal(self, *args)

    def getHereGoal(self):
        """getHereGoal(self) -> char"""
        return _ArNetworkingPy.ArServerClientIdentifier_getHereGoal(self)

    def matches(self, *args):
        """matches(self, ArServerClientIdentifier identifier, bool matchConnectionID) -> bool"""
        return _ArNetworkingPy.ArServerClientIdentifier_matches(self, *args)

    def rebuildIDString(self):
        """rebuildIDString(self)"""
        return _ArNetworkingPy.ArServerClientIdentifier_rebuildIDString(self)

ArServerClientIdentifier_swigregister = _ArNetworkingPy.ArServerClientIdentifier_swigregister
ArServerClientIdentifier_swigregister(ArServerClientIdentifier)

class ArServerClientData(_object):
    """Proxy of C++ ArServerClientData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerClientData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerClientData, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerData serverData, long mSecInterval, ArNetPacket packet) -> ArServerClientData"""
        this = _ArNetworkingPy.new_ArServerClientData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerClientData
    __del__ = lambda self : None;
    def getServerData(self):
        """getServerData(self) -> ArServerData"""
        return _ArNetworkingPy.ArServerClientData_getServerData(self)

    def getMSec(self):
        """getMSec(self) -> long"""
        return _ArNetworkingPy.ArServerClientData_getMSec(self)

    def getPacket(self):
        """getPacket(self) -> ArNetPacket"""
        return _ArNetworkingPy.ArServerClientData_getPacket(self)

    def getLastSent(self):
        """getLastSent(self) -> ArTime"""
        return _ArNetworkingPy.ArServerClientData_getLastSent(self)

    def setLastSentToNow(self):
        """setLastSentToNow(self)"""
        return _ArNetworkingPy.ArServerClientData_setLastSentToNow(self)

    def setMSec(self, *args):
        """setMSec(self, long mSec)"""
        return _ArNetworkingPy.ArServerClientData_setMSec(self, *args)

    def setPacket(self, *args):
        """setPacket(self, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerClientData_setPacket(self, *args)

ArServerClientData_swigregister = _ArNetworkingPy.ArServerClientData_swigregister
ArServerClientData_swigregister(ArServerClientData)

class ArServerCommands(_object):
    """Proxy of C++ ArServerCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerCommands, name)
    __repr__ = _swig_repr
    SHUTDOWN = _ArNetworkingPy.ArServerCommands_SHUTDOWN
    INTRODUCTION = _ArNetworkingPy.ArServerCommands_INTRODUCTION
    UDP_INTRODUCTION = _ArNetworkingPy.ArServerCommands_UDP_INTRODUCTION
    UDP_CONFIRMATION = _ArNetworkingPy.ArServerCommands_UDP_CONFIRMATION
    CONNECTED = _ArNetworkingPy.ArServerCommands_CONNECTED
    REJECTED = _ArNetworkingPy.ArServerCommands_REJECTED
    TCP_ONLY = _ArNetworkingPy.ArServerCommands_TCP_ONLY
    LIST = _ArNetworkingPy.ArServerCommands_LIST
    LISTSINGLE = _ArNetworkingPy.ArServerCommands_LISTSINGLE
    LISTARGRET = _ArNetworkingPy.ArServerCommands_LISTARGRET
    LISTARGRETSINGLE = _ArNetworkingPy.ArServerCommands_LISTARGRETSINGLE
    LISTGROUPANDFLAGS = _ArNetworkingPy.ArServerCommands_LISTGROUPANDFLAGS
    LISTGROUPANDFLAGSSINGLE = _ArNetworkingPy.ArServerCommands_LISTGROUPANDFLAGSSINGLE
    TYPE_UNSPECIFIED = _ArNetworkingPy.ArServerCommands_TYPE_UNSPECIFIED
    TYPE_REAL = _ArNetworkingPy.ArServerCommands_TYPE_REAL
    TYPE_SIMULATED = _ArNetworkingPy.ArServerCommands_TYPE_SIMULATED
    TYPE_NONE = _ArNetworkingPy.ArServerCommands_TYPE_NONE
    def toString(*args):
        """toString(Type type) -> char"""
        return _ArNetworkingPy.ArServerCommands_toString(*args)

    if _newclass:toString = staticmethod(toString)
    __swig_getmethods__["toString"] = lambda x: toString
    def __init__(self): 
        """__init__(self) -> ArServerCommands"""
        this = _ArNetworkingPy.new_ArServerCommands()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerCommands
    __del__ = lambda self : None;
ArServerCommands_swigregister = _ArNetworkingPy.ArServerCommands_swigregister
ArServerCommands_swigregister(ArServerCommands)

def ArServerCommands_toString(*args):
  """ArServerCommands_toString(Type type) -> char"""
  return _ArNetworkingPy.ArServerCommands_toString(*args)

class ArServerData(_object):
    """Proxy of C++ ArServerData class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerData, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup = None, char dataFlags = None, 
            ArRetFunctor1<(long,unsigned int)> getFrequencyFunctor = None, 
            ArFunctor2<(long,unsigned int)> requestChangedFunctor = None, 
            ArRetFunctor2<(bool,p.ArServerClient,p.ArNetPacket)> requestOnceFunctor = None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup = None, char dataFlags = None, 
            ArRetFunctor1<(long,unsigned int)> getFrequencyFunctor = None, 
            ArFunctor2<(long,unsigned int)> requestChangedFunctor = None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup = None, char dataFlags = None, 
            ArRetFunctor1<(long,unsigned int)> getFrequencyFunctor = None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup = None, char dataFlags = None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription, 
            char commandGroup = None) -> ArServerData
        __init__(self, char name, char description, unsigned int command, 
            ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor, 
            char argumentDescription, char returnDescription) -> ArServerData
        """
        this = _ArNetworkingPy.new_ArServerData(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerData
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> char"""
        return _ArNetworkingPy.ArServerData_getName(self)

    def getDescription(self):
        """getDescription(self) -> char"""
        return _ArNetworkingPy.ArServerData_getDescription(self)

    def getCommand(self):
        """getCommand(self) -> unsigned int"""
        return _ArNetworkingPy.ArServerData_getCommand(self)

    def getFunctor(self):
        """getFunctor(self) -> ArFunctor2<(p.ArServerClient,p.ArNetPacket)>"""
        return _ArNetworkingPy.ArServerData_getFunctor(self)

    def getArgumentDescription(self):
        """getArgumentDescription(self) -> char"""
        return _ArNetworkingPy.ArServerData_getArgumentDescription(self)

    def getReturnDescription(self):
        """getReturnDescription(self) -> char"""
        return _ArNetworkingPy.ArServerData_getReturnDescription(self)

    def getCommandGroup(self):
        """getCommandGroup(self) -> char"""
        return _ArNetworkingPy.ArServerData_getCommandGroup(self)

    def getRequestOnceFunctor(self):
        """getRequestOnceFunctor(self) -> ArRetFunctor2<(bool,p.ArServerClient,p.ArNetPacket)>"""
        return _ArNetworkingPy.ArServerData_getRequestOnceFunctor(self)

    def hasDataFlag(self, *args):
        """hasDataFlag(self, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerData_hasDataFlag(self, *args)

    def addDataFlags(self, *args):
        """addDataFlags(self, char dataFlags) -> bool"""
        return _ArNetworkingPy.ArServerData_addDataFlags(self, *args)

    def remDataFlag(self, *args):
        """remDataFlag(self, char dataFlag) -> bool"""
        return _ArNetworkingPy.ArServerData_remDataFlag(self, *args)

    def isSlowPacket(self):
        """isSlowPacket(self) -> bool"""
        return _ArNetworkingPy.ArServerData_isSlowPacket(self)

    def isIdlePacket(self):
        """isIdlePacket(self) -> bool"""
        return _ArNetworkingPy.ArServerData_isIdlePacket(self)

    def getDataFlagsString(self):
        """getDataFlagsString(self) -> char"""
        return _ArNetworkingPy.ArServerData_getDataFlagsString(self)

    def callRequestChangedFunctor(self):
        """callRequestChangedFunctor(self)"""
        return _ArNetworkingPy.ArServerData_callRequestChangedFunctor(self)

ArServerData_swigregister = _ArNetworkingPy.ArServerData_swigregister
ArServerData_swigregister(ArServerData)

class ArServerFileLister(_object):
    """Proxy of C++ ArServerFileLister class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileLister, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileLister, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, char topDir, char defaultUploadDownloadDir = None) -> ArServerFileLister
        __init__(self, ArServerBase server, char topDir) -> ArServerFileLister
        """
        this = _ArNetworkingPy.new_ArServerFileLister(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileLister
    __del__ = lambda self : None;
    def getDirListing(self, *args):
        """getDirListing(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDirListing(self, *args)

    def getDirListingMultiplePackets(self, *args):
        """getDirListingMultiplePackets(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDirListingMultiplePackets(self, *args)

    def getDefaultUploadDownloadDir(self, *args):
        """getDefaultUploadDownloadDir(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileLister_getDefaultUploadDownloadDir(self, *args)

ArServerFileLister_swigregister = _ArNetworkingPy.ArServerFileLister_swigregister
ArServerFileLister_swigregister(ArServerFileLister)

class ArServerFileToClient(_object):
    """Proxy of C++ ArServerFileToClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileToClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileToClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, char topDir) -> ArServerFileToClient"""
        this = _ArNetworkingPy.new_ArServerFileToClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileToClient
    __del__ = lambda self : None;
    def getFile(self, *args):
        """getFile(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileToClient_getFile(self, *args)

    def getFileWithTimestamp(self, *args):
        """getFileWithTimestamp(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileToClient_getFileWithTimestamp(self, *args)

ArServerFileToClient_swigregister = _ArNetworkingPy.ArServerFileToClient_swigregister
ArServerFileToClient_swigregister(ArServerFileToClient)

class ArServerFileFromClient(_object):
    """Proxy of C++ ArServerFileFromClient class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerFileFromClient, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerFileFromClient, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, char topDir, char tempDir) -> ArServerFileFromClient"""
        this = _ArNetworkingPy.new_ArServerFileFromClient(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerFileFromClient
    __del__ = lambda self : None;
    def putFile(self, *args):
        """putFile(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFile(self, *args)

    def putFileInterleaved(self, *args):
        """putFileInterleaved(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileInterleaved(self, *args)

    def putFileWithTimestamp(self, *args):
        """putFileWithTimestamp(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileWithTimestamp(self, *args)

    def putFileWithTimestampInterleaved(self, *args):
        """putFileWithTimestampInterleaved(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerFileFromClient_putFileWithTimestampInterleaved(self, *args)

    def addPreMoveCallback(self, *args):
        """
        addPreMoveCallback(self, ArFunctor functor, Pos position = LAST)
        addPreMoveCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerFileFromClient_addPreMoveCallback(self, *args)

    def remPreMoveCallback(self, *args):
        """remPreMoveCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerFileFromClient_remPreMoveCallback(self, *args)

    def addPostMoveCallback(self, *args):
        """
        addPostMoveCallback(self, ArFunctor functor, Pos position = LAST)
        addPostMoveCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerFileFromClient_addPostMoveCallback(self, *args)

    def remPostMoveCallback(self, *args):
        """remPostMoveCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerFileFromClient_remPostMoveCallback(self, *args)

    def getMovingFileName(self):
        """getMovingFileName(self) -> char"""
        return _ArNetworkingPy.ArServerFileFromClient_getMovingFileName(self)

ArServerFileFromClient_swigregister = _ArNetworkingPy.ArServerFileFromClient_swigregister
ArServerFileFromClient_swigregister(ArServerFileFromClient)

class ArServerDeleteFileOnServer(_object):
    """Proxy of C++ ArServerDeleteFileOnServer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerDeleteFileOnServer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerDeleteFileOnServer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, char topDir) -> ArServerDeleteFileOnServer"""
        this = _ArNetworkingPy.new_ArServerDeleteFileOnServer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerDeleteFileOnServer
    __del__ = lambda self : None;
    def deleteFile(self, *args):
        """deleteFile(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_deleteFile(self, *args)

    def addPreDeleteCallback(self, *args):
        """
        addPreDeleteCallback(self, ArFunctor functor, Pos position = LAST)
        addPreDeleteCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerDeleteFileOnServer_addPreDeleteCallback(self, *args)

    def remPreDeleteCallback(self, *args):
        """remPreDeleteCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_remPreDeleteCallback(self, *args)

    def addPostDeleteCallback(self, *args):
        """
        addPostDeleteCallback(self, ArFunctor functor, Pos position = LAST)
        addPostDeleteCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerDeleteFileOnServer_addPostDeleteCallback(self, *args)

    def remPostDeleteCallback(self, *args):
        """remPostDeleteCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_remPostDeleteCallback(self, *args)

    def getDeletingFileName(self):
        """getDeletingFileName(self) -> char"""
        return _ArNetworkingPy.ArServerDeleteFileOnServer_getDeletingFileName(self)

ArServerDeleteFileOnServer_swigregister = _ArNetworkingPy.ArServerDeleteFileOnServer_swigregister
ArServerDeleteFileOnServer_swigregister(ArServerDeleteFileOnServer)

class ArServerHandlerCamera(AriaPy.ArCameraCollectionItem):
    """Proxy of C++ ArServerHandlerCamera class"""
    __swig_setmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCamera, name, value)
    __swig_getmethods__ = {}
    for _s in [AriaPy.ArCameraCollectionItem]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCamera, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char cameraName, ArServerBase server, ArRobot robot, 
            ArPTZ camera, ArCameraCollection collection) -> ArServerHandlerCamera
        __init__(self, ArServerBase server, ArRobot robot, ArPTZ camera) -> ArServerHandlerCamera
        """
        this = _ArNetworkingPy.new_ArServerHandlerCamera(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCamera
    __del__ = lambda self : None;
    def setCameraAbs(self, *args):
        """
        setCameraAbs(self, double pan, double tilt, double zoom, bool lockRobot = True)
        setCameraAbs(self, double pan, double tilt, double zoom)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraAbs(self, *args)

    def setCameraRel(self, *args):
        """
        setCameraRel(self, double pan, double tilt, double zoom, bool lockRobot = True)
        setCameraRel(self, double pan, double tilt, double zoom)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraRel(self, *args)

    def setCameraPct(self, *args):
        """
        setCameraPct(self, double panPct, double tiltPct, bool lockRobot = True)
        setCameraPct(self, double panPct, double tiltPct)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_setCameraPct(self, *args)

    def resetCamera(self, lockRobot = True):
        """
        resetCamera(self, bool lockRobot = True)
        resetCamera(self)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_resetCamera(self, lockRobot)

    def cameraModeLookAtGoal(self):
        """cameraModeLookAtGoal(self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoal(self)

    def cameraModeLookAtPoint(self, *args):
        """
        cameraModeLookAtPoint(self, ArPose pose, bool controlZoom = True)
        cameraModeLookAtPoint(self, ArPose pose)
        """
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtPoint(self, *args)

    def cameraModeLookAtGoalSetGoal(self, *args):
        """cameraModeLookAtGoalSetGoal(self, ArPose pose)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoalSetGoal(self, *args)

    def cameraModeLookAtGoalClearGoal(self):
        """cameraModeLookAtGoalClearGoal(self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModeLookAtGoalClearGoal(self)

    def cameraModePosition(self):
        """cameraModePosition(self)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraModePosition(self)

    def getCameraName(self):
        """getCameraName(self) -> char"""
        return _ArNetworkingPy.ArServerHandlerCamera_getCameraName(self)

    def addToCameraCollection(self, *args):
        """addToCameraCollection(self, ArCameraCollection collection)"""
        return _ArNetworkingPy.ArServerHandlerCamera_addToCameraCollection(self, *args)

    def handleGetCameraData(self, *args):
        """handleGetCameraData(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraData(self, *args)

    def handleGetCameraInfo(self, *args):
        """handleGetCameraInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraInfo(self, *args)

    def handleSetCameraAbs(self, *args):
        """handleSetCameraAbs(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraAbs(self, *args)

    def handleSetCameraPct(self, *args):
        """handleSetCameraPct(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraPct(self, *args)

    def handleSetCameraRel(self, *args):
        """handleSetCameraRel(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraRel(self, *args)

    def handleGetCameraModeList(self, *args):
        """handleGetCameraModeList(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleGetCameraModeList(self, *args)

    def handleCameraModeUpdated(self, *args):
        """handleCameraModeUpdated(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleCameraModeUpdated(self, *args)

    def handleSetCameraMode(self, *args):
        """handleSetCameraMode(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleSetCameraMode(self, *args)

    def handleResetCamera(self, *args):
        """handleResetCamera(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_handleResetCamera(self, *args)

    def camera(self, *args):
        """camera(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_camera(self, *args)

    def cameraAbs(self, *args):
        """cameraAbs(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraAbs(self, *args)

    def cameraPct(self, *args):
        """cameraPct(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraPct(self, *args)

    def cameraUpdate(self, *args):
        """cameraUpdate(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraUpdate(self, *args)

    def cameraInfo(self, *args):
        """cameraInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCamera_cameraInfo(self, *args)

ArServerHandlerCamera_swigregister = _ArNetworkingPy.ArServerHandlerCamera_swigregister
ArServerHandlerCamera_swigregister(ArServerHandlerCamera)

class ArServerHandlerCameraCollection(_object):
    """Proxy of C++ ArServerHandlerCameraCollection class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCameraCollection, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCameraCollection, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArCameraCollection cameraCollection) -> ArServerHandlerCameraCollection"""
        this = _ArNetworkingPy.new_ArServerHandlerCameraCollection(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCameraCollection
    __del__ = lambda self : None;
    def getCameraList(self, *args):
        """getCameraList(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_getCameraList(self, *args)

    def setParams(self, *args):
        """setParams(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_setParams(self, *args)

    def handleCameraCollectionModified(self):
        """handleCameraCollectionModified(self)"""
        return _ArNetworkingPy.ArServerHandlerCameraCollection_handleCameraCollectionModified(self)

ArServerHandlerCameraCollection_swigregister = _ArNetworkingPy.ArServerHandlerCameraCollection_swigregister
ArServerHandlerCameraCollection_swigregister(ArServerHandlerCameraCollection)

class ArServerHandlerCommMonitor(_object):
    """Proxy of C++ ArServerHandlerCommMonitor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCommMonitor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCommMonitor, name)
    __repr__ = _swig_repr
    MIN_HEARTBEAT_INTERVAL = _ArNetworkingPy.ArServerHandlerCommMonitor_MIN_HEARTBEAT_INTERVAL
    DEFAULT_HEARTBEAT_INTERVAL = _ArNetworkingPy.ArServerHandlerCommMonitor_DEFAULT_HEARTBEAT_INTERVAL
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, int heartbeatInterval = DEFAULT_HEARTBEAT_INTERVAL) -> ArServerHandlerCommMonitor
        __init__(self, ArServerBase server) -> ArServerHandlerCommMonitor
        """
        this = _ArNetworkingPy.new_ArServerHandlerCommMonitor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCommMonitor
    __del__ = lambda self : None;
    def handleGetHeartbeatInterval(self, *args):
        """handleGetHeartbeatInterval(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleGetHeartbeatInterval(self, *args)

    def handleAckCommTcp(self, *args):
        """handleAckCommTcp(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleAckCommTcp(self, *args)

    def handleAckCommUdp(self, *args):
        """handleAckCommUdp(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_handleAckCommUdp(self, *args)

    def cycleCallback(self):
        """cycleCallback(self)"""
        return _ArNetworkingPy.ArServerHandlerCommMonitor_cycleCallback(self)

ArServerHandlerCommMonitor_swigregister = _ArNetworkingPy.ArServerHandlerCommMonitor_swigregister
ArServerHandlerCommMonitor_swigregister(ArServerHandlerCommMonitor)

class ArServerHandlerCommands(_object):
    """Proxy of C++ ArServerHandlerCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerCommands, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server) -> ArServerHandlerCommands"""
        this = _ArNetworkingPy.new_ArServerHandlerCommands(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerCommands
    __del__ = lambda self : None;
    def setTextServer(self, *args):
        """setTextServer(self, ArNetServer textServer)"""
        return _ArNetworkingPy.ArServerHandlerCommands_setTextServer(self, *args)

    def addCommand(self, *args):
        """
        addCommand(self, char name, char description, ArFunctor functor, char commandGroup = None) -> bool
        addCommand(self, char name, char description, ArFunctor functor) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerCommands_addCommand(self, *args)

    def addStringCommand(self, *args):
        """
        addStringCommand(self, char name, char description, ArFunctor1<(p.ArArgumentBuilder)> functor, 
            char commandGroup = None) -> bool
        addStringCommand(self, char name, char description, ArFunctor1<(p.ArArgumentBuilder)> functor) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerCommands_addStringCommand(self, *args)

    def setPrefix(self, *args):
        """setPrefix(self, char prefix)"""
        return _ArNetworkingPy.ArServerHandlerCommands_setPrefix(self, *args)

    def getPrefix(self):
        """getPrefix(self) -> char"""
        return _ArNetworkingPy.ArServerHandlerCommands_getPrefix(self)

    def netListCommands(self, *args):
        """netListCommands(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommands_netListCommands(self, *args)

    def netListStringCommands(self, *args):
        """netListStringCommands(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerCommands_netListStringCommands(self, *args)

ArServerHandlerCommands_swigregister = _ArNetworkingPy.ArServerHandlerCommands_swigregister
ArServerHandlerCommands_swigregister(ArServerHandlerCommands)

class ArServerHandlerConfig(_object):
    """Proxy of C++ ArServerHandlerConfig class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArConfig config, char defaultFile = None, 
            char defaultFileBaseDirectory = None, 
            bool allowFactory = True, char robotName = None, 
            bool preventChanges = False, char preventChangesString = None) -> ArServerHandlerConfig
        __init__(self, ArServerBase server, ArConfig config, char defaultFile = None, 
            char defaultFileBaseDirectory = None, 
            bool allowFactory = True, char robotName = None, 
            bool preventChanges = False) -> ArServerHandlerConfig
        __init__(self, ArServerBase server, ArConfig config, char defaultFile = None, 
            char defaultFileBaseDirectory = None, 
            bool allowFactory = True, char robotName = None) -> ArServerHandlerConfig
        __init__(self, ArServerBase server, ArConfig config, char defaultFile = None, 
            char defaultFileBaseDirectory = None, 
            bool allowFactory = True) -> ArServerHandlerConfig
        __init__(self, ArServerBase server, ArConfig config, char defaultFile = None, 
            char defaultFileBaseDirectory = None) -> ArServerHandlerConfig
        __init__(self, ArServerBase server, ArConfig config, char defaultFile = None) -> ArServerHandlerConfig
        __init__(self, ArServerBase server, ArConfig config) -> ArServerHandlerConfig
        """
        this = _ArNetworkingPy.new_ArServerHandlerConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerConfig
    __del__ = lambda self : None;
    def reloadConfig(self, *args):
        """reloadConfig(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_reloadConfig(self, *args)

    def getConfigBySections(self, *args):
        """getConfigBySections(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySections(self, *args)

    def getConfigBySectionsV2(self, *args):
        """getConfigBySectionsV2(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySectionsV2(self, *args)

    def getConfigBySectionsV3(self, *args):
        """getConfigBySectionsV3(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySectionsV3(self, *args)

    def getConfigBySectionsV4(self, *args):
        """getConfigBySectionsV4(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigBySectionsV4(self, *args)

    def getConfig(self, *args):
        """getConfig(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfig(self, *args)

    def setConfig(self, *args):
        """setConfig(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfig(self, *args)

    def setConfigParam(self, *args):
        """setConfigParam(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfigParam(self, *args)

    def setConfigBySections(self, *args):
        """setConfigBySections(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfigBySections(self, *args)

    def setConfigBySectionsV2(self, *args):
        """setConfigBySectionsV2(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setConfigBySectionsV2(self, *args)

    def getConfigDefaults(self, *args):
        """getConfigDefaults(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigDefaults(self, *args)

    def getConfigSectionFlags(self, *args):
        """getConfigSectionFlags(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getConfigSectionFlags(self, *args)

    def getLastEditablePriority(self, *args):
        """getLastEditablePriority(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerConfig_getLastEditablePriority(self, *args)

    def addPreWriteCallback(self, *args):
        """
        addPreWriteCallback(self, ArFunctor functor, Pos position = LAST)
        addPreWriteCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addPreWriteCallback(self, *args)

    def remPreWriteCallback(self, *args):
        """remPreWriteCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remPreWriteCallback(self, *args)

    def addPostWriteCallback(self, *args):
        """
        addPostWriteCallback(self, ArFunctor functor, Pos position = LAST)
        addPostWriteCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addPostWriteCallback(self, *args)

    def remPostWriteCallback(self, *args):
        """remPostWriteCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remPostWriteCallback(self, *args)

    def addConfigUpdatedCallback(self, *args):
        """
        addConfigUpdatedCallback(self, ArFunctor functor, Pos position = LAST)
        addConfigUpdatedCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addConfigUpdatedCallback(self, *args)

    def remConfigUpdatedCallback(self, *args):
        """remConfigUpdatedCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remConfigUpdatedCallback(self, *args)

    def restartIO(self, *args):
        """restartIO(self, char reason)"""
        return _ArNetworkingPy.ArServerHandlerConfig_restartIO(self, *args)

    def restartSoftware(self, *args):
        """restartSoftware(self, char reason)"""
        return _ArNetworkingPy.ArServerHandlerConfig_restartSoftware(self, *args)

    def restartHardware(self, *args):
        """restartHardware(self, char reason)"""
        return _ArNetworkingPy.ArServerHandlerConfig_restartHardware(self, *args)

    def addRestartIOCB(self, *args):
        """
        addRestartIOCB(self, ArFunctor functor, int position = 50)
        addRestartIOCB(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_addRestartIOCB(self, *args)

    def remRestartIOCB(self, *args):
        """remRestartIOCB(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerConfig_remRestartIOCB(self, *args)

    def setRestartSoftwareCB(self, *args):
        """setRestartSoftwareCB(self, ArFunctor restartServerCB)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setRestartSoftwareCB(self, *args)

    def getRestartSoftwareCB(self):
        """getRestartSoftwareCB(self) -> ArFunctor"""
        return _ArNetworkingPy.ArServerHandlerConfig_getRestartSoftwareCB(self)

    def setRestartHardwareCB(self, *args):
        """setRestartHardwareCB(self, ArFunctor restartRobotCB)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setRestartHardwareCB(self, *args)

    def getRestartHardwareCB(self):
        """getRestartHardwareCB(self) -> ArFunctor"""
        return _ArNetworkingPy.ArServerHandlerConfig_getRestartHardwareCB(self)

    def lockConfig(self):
        """lockConfig(self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_lockConfig(self)

    def tryLockConfig(self):
        """tryLockConfig(self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_tryLockConfig(self)

    def unlockConfig(self):
        """unlockConfig(self) -> int"""
        return _ArNetworkingPy.ArServerHandlerConfig_unlockConfig(self)

    def writeConfig(self):
        """writeConfig(self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_writeConfig(self)

    def configUpdated(self, client = None):
        """
        configUpdated(self, ArServerClient client = None) -> bool
        configUpdated(self) -> bool
        """
        return _ArNetworkingPy.ArServerHandlerConfig_configUpdated(self, client)

    def setPreventChanges(self, preventChanges = False, preventChangesString = None):
        """
        setPreventChanges(self, bool preventChanges = False, char preventChangesString = None)
        setPreventChanges(self, bool preventChanges = False)
        setPreventChanges(self)
        """
        return _ArNetworkingPy.ArServerHandlerConfig_setPreventChanges(self, preventChanges, preventChangesString)

    def loadDefaultsFromFile(self):
        """loadDefaultsFromFile(self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_loadDefaultsFromFile(self)

    def loadDefaultsFromPacket(self, *args):
        """loadDefaultsFromPacket(self, ArNetPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_loadDefaultsFromPacket(self, *args)

    def createEmptyConfigDefaults(self):
        """createEmptyConfigDefaults(self)"""
        return _ArNetworkingPy.ArServerHandlerConfig_createEmptyConfigDefaults(self)

    def setAllowFactory(self, *args):
        """setAllowFactory(self, bool allowFactory)"""
        return _ArNetworkingPy.ArServerHandlerConfig_setAllowFactory(self, *args)

    def getAllowFactory(self):
        """getAllowFactory(self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerConfig_getAllowFactory(self)

ArServerHandlerConfig_swigregister = _ArNetworkingPy.ArServerHandlerConfig_swigregister
ArServerHandlerConfig_swigregister(ArServerHandlerConfig)

class ArServerHandlerMap(_object):
    """Proxy of C++ ArServerHandlerMap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerMap, name)
    __repr__ = _swig_repr
    LINES = _ArNetworkingPy.ArServerHandlerMap_LINES
    POINTS = _ArNetworkingPy.ArServerHandlerMap_POINTS
    BOTH = _ArNetworkingPy.ArServerHandlerMap_BOTH
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArMapInterface arMap = None, DataToSend dataToSend = BOTH) -> ArServerHandlerMap
        __init__(self, ArServerBase server, ArMapInterface arMap = None) -> ArServerHandlerMap
        __init__(self, ArServerBase server) -> ArServerHandlerMap
        """
        this = _ArNetworkingPy.new_ArServerHandlerMap(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerMap
    __del__ = lambda self : None;
    def loadMap(self, *args):
        """loadMap(self, char mapFile) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMap_loadMap(self, *args)

    def useMap(self, *args):
        """
        useMap(self, ArMapInterface mapObj, bool takeOwnershipOfMap = False)
        useMap(self, ArMapInterface mapObj)
        """
        return _ArNetworkingPy.ArServerHandlerMap_useMap(self, *args)

    def getMap(self):
        """getMap(self) -> ArMapInterface"""
        return _ArNetworkingPy.ArServerHandlerMap_getMap(self)

    def serverGetMapId(self, *args):
        """serverGetMapId(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapId(self, *args)

    def serverGetMapName(self, *args):
        """serverGetMapName(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapName(self, *args)

    def serverGetMap(self, *args):
        """serverGetMap(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMap(self, *args)

    def serverGetMapBinary(self, *args):
        """serverGetMapBinary(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapBinary(self, *args)

    def serverGetMapMultiScans(self, *args):
        """serverGetMapMultiScans(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapMultiScans(self, *args)

    def serverGetMapWithMaxCategory(self, *args):
        """serverGetMapWithMaxCategory(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetMapWithMaxCategory(self, *args)

    def serverGetGoals(self, *args):
        """serverGetGoals(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMap_serverGetGoals(self, *args)

    def setDataToSend(self, *args):
        """setDataToSend(self, DataToSend dataToSend)"""
        return _ArNetworkingPy.ArServerHandlerMap_setDataToSend(self, *args)

    def getDataToSend(self):
        """getDataToSend(self) -> DataToSend"""
        return _ArNetworkingPy.ArServerHandlerMap_getDataToSend(self)

ArServerHandlerMap_swigregister = _ArNetworkingPy.ArServerHandlerMap_swigregister
ArServerHandlerMap_swigregister(ArServerHandlerMap)

class ArServerHandlerMapping(_object):
    """Proxy of C++ ArServerHandlerMapping class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerHandlerMapping, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerHandlerMapping, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory = "", char tempDirectory = "", 
            bool useReflectorValues = False, ArLaser laser2 = None, 
            char sickSuffix = None, char sick2Suffix = None, 
            std::list<(p.ArLaser,std::allocator<(p.ArLaser)>)> extraLasers = None) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory = "", char tempDirectory = "", 
            bool useReflectorValues = False, ArLaser laser2 = None, 
            char sickSuffix = None, char sick2Suffix = None) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory = "", char tempDirectory = "", 
            bool useReflectorValues = False, ArLaser laser2 = None, 
            char sickSuffix = None) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory = "", char tempDirectory = "", 
            bool useReflectorValues = False, ArLaser laser2 = None) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory = "", char tempDirectory = "", 
            bool useReflectorValues = False) -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory = "", char tempDirectory = "") -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser, 
            char baseDirectory = "") -> ArServerHandlerMapping
        __init__(self, ArServerBase server, ArRobot robot, ArLaser laser) -> ArServerHandlerMapping
        """
        this = _ArNetworkingPy.new_ArServerHandlerMapping(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerHandlerMapping
    __del__ = lambda self : None;
    def serverMappingStart(self, *args):
        """serverMappingStart(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingStart(self, *args)

    def serverMappingEnd(self, *args):
        """serverMappingEnd(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingEnd(self, *args)

    def serverMappingStatus(self, *args):
        """serverMappingStatus(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerHandlerMapping_serverMappingStatus(self, *args)

    def isMapping(self):
        """isMapping(self) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_isMapping(self)

    def forceReading(self):
        """forceReading(self)"""
        return _ArNetworkingPy.ArServerHandlerMapping_forceReading(self)

    def getFileName(self):
        """getFileName(self) -> char"""
        return _ArNetworkingPy.ArServerHandlerMapping_getFileName(self)

    def getMapName(self):
        """getMapName(self) -> char"""
        return _ArNetworkingPy.ArServerHandlerMapping_getMapName(self)

    def addSimpleCommands(self, *args):
        """addSimpleCommands(self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addSimpleCommands(self, *args)

    def simpleLoopStart(self, *args):
        """simpleLoopStart(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerHandlerMapping_simpleLoopStart(self, *args)

    def simpleLoopEnd(self, *args):
        """simpleLoopEnd(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerHandlerMapping_simpleLoopEnd(self, *args)

    def addStringForStartOfLogs(self, *args):
        """
        addStringForStartOfLogs(self, char str, Pos position = LAST)
        addStringForStartOfLogs(self, char str)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addStringForStartOfLogs(self, *args)

    def remStringForStartOfLogs(self, *args):
        """remStringForStartOfLogs(self, char str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remStringForStartOfLogs(self, *args)

    def addTagToLog(self, *args):
        """addTagToLog(self, char str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addTagToLog(self, *args)

    def addInfoToLog(self, *args):
        """addInfoToLog(self, char str)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addInfoToLog(self, *args)

    def addLocationData(self, *args):
        """addLocationData(self, char name, ArRetFunctor3<(int,ArTime,p.ArPose,p.ArPoseWithTime)> functor) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_addLocationData(self, *args)

    def addMappingStartCallback(self, *args):
        """
        addMappingStartCallback(self, ArFunctor functor, Pos position = LAST)
        addMappingStartCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingStartCallback(self, *args)

    def remMappingStartCallback(self, *args):
        """remMappingStartCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingStartCallback(self, *args)

    def addMappingBegunCallback(self, *args):
        """
        addMappingBegunCallback(self, ArFunctor functor, Pos position = LAST)
        addMappingBegunCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingBegunCallback(self, *args)

    def remMappingBegunCallback(self, *args):
        """remMappingBegunCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingBegunCallback(self, *args)

    def addMappingEndCallback(self, *args):
        """
        addMappingEndCallback(self, ArFunctor functor, Pos position = LAST)
        addMappingEndCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingEndCallback(self, *args)

    def remMappingEndCallback(self, *args):
        """remMappingEndCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingEndCallback(self, *args)

    def addMappingEndedCallback(self, *args):
        """
        addMappingEndedCallback(self, ArFunctor functor, Pos position = LAST)
        addMappingEndedCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addMappingEndedCallback(self, *args)

    def remMappingEndedCallback(self, *args):
        """remMappingEndedCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remMappingEndedCallback(self, *args)

    def addPreMoveCallback(self, *args):
        """
        addPreMoveCallback(self, ArFunctor functor, Pos position = LAST)
        addPreMoveCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addPreMoveCallback(self, *args)

    def remPreMoveCallback(self, *args):
        """remPreMoveCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remPreMoveCallback(self, *args)

    def addPostMoveCallback(self, *args):
        """
        addPostMoveCallback(self, ArFunctor functor, Pos position = LAST)
        addPostMoveCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerHandlerMapping_addPostMoveCallback(self, *args)

    def remPostMoveCallback(self, *args):
        """remPostMoveCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerHandlerMapping_remPostMoveCallback(self, *args)

    def packetHandler(self, *args):
        """packetHandler(self, ArRobotPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerHandlerMapping_packetHandler(self, *args)

    def getLocationDataMap(self):
        """getLocationDataMap(self) -> std::map<(std::string,p.ArRetFunctor3<(int,ArTime,p.ArPose,p.ArPoseWithTime)>,ArStrCaseCmpOp,std::allocator<(std::pair<(q(const).std::string,p.ArRetFunctor3<(int,ArTime,p.ArPose,p.ArPoseWithTime)>)>)>)>"""
        return _ArNetworkingPy.ArServerHandlerMapping_getLocationDataMap(self)

    def addStringsForStartOfLogToMap(self, *args):
        """addStringsForStartOfLogToMap(self, ArMap arMap)"""
        return _ArNetworkingPy.ArServerHandlerMapping_addStringsForStartOfLogToMap(self, *args)

    def getZipFile(self):
        """getZipFile(self) -> ArZippable"""
        return _ArNetworkingPy.ArServerHandlerMapping_getZipFile(self)

    def getSnapshotZipFile(self):
        """getSnapshotZipFile(self) -> ArZippable"""
        return _ArNetworkingPy.ArServerHandlerMapping_getSnapshotZipFile(self)

    def setZipFile(self, *args):
        """setZipFile(self, ArZippable zipFile)"""
        return _ArNetworkingPy.ArServerHandlerMapping_setZipFile(self, *args)

    def setSnapshotZipFile(self, *args):
        """setSnapshotZipFile(self, ArZippable zipFile)"""
        return _ArNetworkingPy.ArServerHandlerMapping_setSnapshotZipFile(self, *args)

ArServerHandlerMapping_swigregister = _ArNetworkingPy.ArServerHandlerMapping_swigregister
ArServerHandlerMapping_swigregister(ArServerHandlerMapping)

class ArServerInfoDrawings(_object):
    """Proxy of C++ ArServerInfoDrawings class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoDrawings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoDrawings, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server) -> ArServerInfoDrawings"""
        this = _ArNetworkingPy.new_ArServerInfoDrawings(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoDrawings
    __del__ = lambda self : None;
    def addDrawing(self, *args):
        """addDrawing(self, ArDrawingData drawingData, char name, ArFunctor2<(p.ArServerClient,p.ArNetPacket)> functor) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addDrawing(self, *args)

    def addRangeDevice(self, *args):
        """addRangeDevice(self, ArRangeDevice rangeDevice) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addRangeDevice(self, *args)

    def addRobotsRangeDevices(self, *args):
        """addRobotsRangeDevices(self, ArRobot robot) -> bool"""
        return _ArNetworkingPy.ArServerInfoDrawings_addRobotsRangeDevices(self, *args)

    def netListDrawings(self, *args):
        """netListDrawings(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netListDrawings(self, *args)

    def netGetDrawingList(self, *args):
        """netGetDrawingList(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netGetDrawingList(self, *args)

    def netRangeDeviceCurrent(self, *args):
        """netRangeDeviceCurrent(self, ArServerClient client, ArNetPacket packet, ArRangeDevice device)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netRangeDeviceCurrent(self, *args)

    def netRangeDeviceCumulative(self, *args):
        """netRangeDeviceCumulative(self, ArServerClient client, ArNetPacket packet, ArRangeDevice device)"""
        return _ArNetworkingPy.ArServerInfoDrawings_netRangeDeviceCumulative(self, *args)

    def internalGetDrawingData(self, *args):
        """internalGetDrawingData(self, char name) -> ArDrawingData"""
        return _ArNetworkingPy.ArServerInfoDrawings_internalGetDrawingData(self, *args)

    def internalGetDrawingCallback(self, *args):
        """internalGetDrawingCallback(self, char name) -> ArFunctor2<(p.ArServerClient,p.ArNetPacket)>"""
        return _ArNetworkingPy.ArServerInfoDrawings_internalGetDrawingCallback(self, *args)

ArServerInfoDrawings_swigregister = _ArNetworkingPy.ArServerInfoDrawings_swigregister
ArServerInfoDrawings_swigregister(ArServerInfoDrawings)

class ArServerInfoRobot(_object):
    """Proxy of C++ ArServerInfoRobot class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoRobot, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoRobot, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot) -> ArServerInfoRobot"""
        this = _ArNetworkingPy.new_ArServerInfoRobot(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoRobot
    __del__ = lambda self : None;
    def update(self, *args):
        """update(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_update(self, *args)

    def updateNumbers(self, *args):
        """updateNumbers(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_updateNumbers(self, *args)

    def updateStrings(self, *args):
        """updateStrings(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_updateStrings(self, *args)

    def batteryInfo(self, *args):
        """batteryInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_batteryInfo(self, *args)

    def physicalInfo(self, *args):
        """physicalInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_physicalInfo(self, *args)

    def activityTimeInfo(self, *args):
        """activityTimeInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoRobot_activityTimeInfo(self, *args)

ArServerInfoRobot_swigregister = _ArNetworkingPy.ArServerInfoRobot_swigregister
ArServerInfoRobot_swigregister(ArServerInfoRobot)

class ArServerInfoSensor(_object):
    """Proxy of C++ ArServerInfoSensor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoSensor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoSensor, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot) -> ArServerInfoSensor"""
        this = _ArNetworkingPy.new_ArServerInfoSensor(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoSensor
    __del__ = lambda self : None;
    def getSensorList(self, *args):
        """getSensorList(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorList(self, *args)

    def getSensorCurrent(self, *args):
        """getSensorCurrent(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorCurrent(self, *args)

    def getSensorCumulative(self, *args):
        """getSensorCumulative(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoSensor_getSensorCumulative(self, *args)

ArServerInfoSensor_swigregister = _ArNetworkingPy.ArServerInfoSensor_swigregister
ArServerInfoSensor_swigregister(ArServerInfoSensor)

class ArServerInfoStrings(_object):
    """Proxy of C++ ArServerInfoStrings class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerInfoStrings, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerInfoStrings, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server) -> ArServerInfoStrings"""
        this = _ArNetworkingPy.new_ArServerInfoStrings(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerInfoStrings
    __del__ = lambda self : None;
    def netGetStringsInfo(self, *args):
        """netGetStringsInfo(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoStrings_netGetStringsInfo(self, *args)

    def netGetStrings(self, *args):
        """netGetStrings(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerInfoStrings_netGetStrings(self, *args)

    def addString(self, *args):
        """addString(self, char name, UByte2 maxLen, ArFunctor2<(p.char,ArTypes::UByte2)> functor)"""
        return _ArNetworkingPy.ArServerInfoStrings_addString(self, *args)

    def getAddStringFunctor(self):
        """getAddStringFunctor(self) -> ArFunctor3<(p.q(const).char,ArTypes::UByte2,p.ArFunctor2<(p.char,ArTypes::UByte2)>)>"""
        return _ArNetworkingPy.ArServerInfoStrings_getAddStringFunctor(self)

    def internalGetStringInfoHolder(self, *args):
        """internalGetStringInfoHolder(self, char name) -> ArStringInfoHolder"""
        return _ArNetworkingPy.ArServerInfoStrings_internalGetStringInfoHolder(self, *args)

ArServerInfoStrings_swigregister = _ArNetworkingPy.ArServerInfoStrings_swigregister
ArServerInfoStrings_swigregister(ArServerInfoStrings)

class ArServerModeDrive(ArServerMode):
    """Proxy of C++ ArServerModeDrive class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeDrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeDrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick = False) -> ArServerModeDrive
        __init__(self, ArServerBase server, ArRobot robot) -> ArServerModeDrive
        """
        this = _ArNetworkingPy.new_ArServerModeDrive(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeDrive
    __del__ = lambda self : None;
    def activate(self):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeDrive_activate(self)

    def deactivate(self):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeDrive_deactivate(self)

    def addControlCommands(self, *args):
        """addControlCommands(self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerModeDrive_addControlCommands(self, *args)

    def driveJoystick(self, *args):
        """
        driveJoystick(self, double vel, double rotVel, bool isActivating = True)
        driveJoystick(self, double vel, double rotVel)
        """
        return _ArNetworkingPy.ArServerModeDrive_driveJoystick(self, *args)

    def serverDriveJoystick(self, *args):
        """serverDriveJoystick(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeDrive_serverDriveJoystick(self, *args)

    def userTask(self):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeDrive_userTask(self)

    def setThrottleParams(self, *args):
        """setThrottleParams(self, int lowSpeed, int highSpeed)"""
        return _ArNetworkingPy.ArServerModeDrive_setThrottleParams(self, *args)

    def getActionGroup(self):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeDrive_getActionGroup(self)

    def setSafeDriving(self, *args):
        """setSafeDriving(self, bool safe)"""
        return _ArNetworkingPy.ArServerModeDrive_setSafeDriving(self, *args)

    def getSafeDriving(self):
        """getSafeDriving(self) -> bool"""
        return _ArNetworkingPy.ArServerModeDrive_getSafeDriving(self)

    def setExtraUnsafeAction(self, *args):
        """setExtraUnsafeAction(self, ArAction action)"""
        return _ArNetworkingPy.ArServerModeDrive_setExtraUnsafeAction(self, *args)

ArServerModeDrive_swigregister = _ArNetworkingPy.ArServerModeDrive_swigregister
ArServerModeDrive_swigregister(ArServerModeDrive)

class ArServerModeIdle(ArServerMode):
    """Proxy of C++ ArServerModeIdle class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeIdle, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeIdle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot) -> ArServerModeIdle"""
        this = _ArNetworkingPy.new_ArServerModeIdle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeIdle
    __del__ = lambda self : None;
    def activate(self):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeIdle_activate(self)

    def deactivate(self):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeIdle_deactivate(self)

    def userTask(self):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeIdle_userTask(self)

    def setModeInterrupted(self, *args):
        """setModeInterrupted(self, ArServerMode modeInterrupted)"""
        return _ArNetworkingPy.ArServerModeIdle_setModeInterrupted(self, *args)

    def getModeInterrupted(self):
        """getModeInterrupted(self) -> ArServerMode"""
        return _ArNetworkingPy.ArServerModeIdle_getModeInterrupted(self)

    def getActionGroup(self):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeIdle_getActionGroup(self)

    def addToConfig(self, *args):
        """
        addToConfig(self, ArConfig config, char section = "Teleop settings")
        addToConfig(self, ArConfig config)
        """
        return _ArNetworkingPy.ArServerModeIdle_addToConfig(self, *args)

    def setUseLocationDependentDevices(self, *args):
        """
        setUseLocationDependentDevices(self, bool useLocationDependentDevices, bool internal = False)
        setUseLocationDependentDevices(self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeIdle_setUseLocationDependentDevices(self, *args)

    def getUseLocationDependentDevices(self):
        """getUseLocationDependentDevices(self) -> bool"""
        return _ArNetworkingPy.ArServerModeIdle_getUseLocationDependentDevices(self)

ArServerModeIdle_swigregister = _ArNetworkingPy.ArServerModeIdle_swigregister
ArServerModeIdle_swigregister(ArServerModeIdle)

class ArServerModeRatioDrive(ArServerMode):
    """Proxy of C++ ArServerModeRatioDrive class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeRatioDrive, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeRatioDrive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick = True, 
            bool useComputerJoystick = True, 
            bool useRobotJoystick = True, bool useServerCommands = True, 
            char name = "ratioDrive", 
            bool robotJoystickOverridesLocks = True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick = True, 
            bool useComputerJoystick = True, 
            bool useRobotJoystick = True, bool useServerCommands = True, 
            char name = "ratioDrive") -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick = True, 
            bool useComputerJoystick = True, 
            bool useRobotJoystick = True, bool useServerCommands = True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick = True, 
            bool useComputerJoystick = True, 
            bool useRobotJoystick = True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick = True, 
            bool useComputerJoystick = True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot, bool takeControlOnJoystick = True) -> ArServerModeRatioDrive
        __init__(self, ArServerBase server, ArRobot robot) -> ArServerModeRatioDrive
        """
        this = _ArNetworkingPy.new_ArServerModeRatioDrive(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeRatioDrive
    __del__ = lambda self : None;
    def activate(self):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_activate(self)

    def deactivate(self):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_deactivate(self)

    def addControlCommands(self, *args):
        """addControlCommands(self, ArServerHandlerCommands handlerCommands)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_addControlCommands(self, *args)

    def ratioDrive(self, *args):
        """
        ratioDrive(self, double transRatio, double rotRatio, double throttleRatio, 
            bool isActivating = False, double latRatio = 0)
        ratioDrive(self, double transRatio, double rotRatio, double throttleRatio, 
            bool isActivating = False)
        ratioDrive(self, double transRatio, double rotRatio, double throttleRatio)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_ratioDrive(self, *args)

    def addToConfig(self, *args):
        """addToConfig(self, ArConfig config, char section)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_addToConfig(self, *args)

    def userTask(self):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_userTask(self)

    def getActionGroup(self):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getActionGroup(self)

    def getActionRatioInput(self):
        """getActionRatioInput(self) -> ArActionRatioInput"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getActionRatioInput(self)

    def setSafeDriving(self, *args):
        """
        setSafeDriving(self, bool safe, bool internal = False)
        setSafeDriving(self, bool safe)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_setSafeDriving(self, *args)

    def getSafeDriving(self):
        """getSafeDriving(self) -> bool"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getSafeDriving(self)

    def setUseLocationDependentDevices(self, *args):
        """
        setUseLocationDependentDevices(self, bool useLocationDependentDevices, bool internal = False)
        setUseLocationDependentDevices(self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_setUseLocationDependentDevices(self, *args)

    def getUseLocationDependentDevices(self):
        """getUseLocationDependentDevices(self) -> bool"""
        return _ArNetworkingPy.ArServerModeRatioDrive_getUseLocationDependentDevices(self)

    def addSafeDrivingCallback(self, *args):
        """
        addSafeDrivingCallback(self, ArFunctor functor, int position = 50)
        addSafeDrivingCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addSafeDrivingCallback(self, *args)

    def remSafeDrivingCallback(self, *args):
        """remSafeDrivingCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remSafeDrivingCallback(self, *args)

    def addUnsafeDrivingCallback(self, *args):
        """
        addUnsafeDrivingCallback(self, ArFunctor functor, int position = 50)
        addUnsafeDrivingCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addUnsafeDrivingCallback(self, *args)

    def remUnsafeDrivingCallback(self, *args):
        """remUnsafeDrivingCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remUnsafeDrivingCallback(self, *args)

    def addDrivingBackwardsCallback(self, *args):
        """
        addDrivingBackwardsCallback(self, ArFunctor functor, int position = 50)
        addDrivingBackwardsCallback(self, ArFunctor functor)
        """
        return _ArNetworkingPy.ArServerModeRatioDrive_addDrivingBackwardsCallback(self, *args)

    def remDrivingBackwardsCallback(self, *args):
        """remDrivingBackwardsCallback(self, ArFunctor functor)"""
        return _ArNetworkingPy.ArServerModeRatioDrive_remDrivingBackwardsCallback(self, *args)

ArServerModeRatioDrive_swigregister = _ArNetworkingPy.ArServerModeRatioDrive_swigregister
ArServerModeRatioDrive_swigregister(ArServerModeRatioDrive)

class ArServerModeStop(ArServerMode):
    """Proxy of C++ ArServerModeStop class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeStop, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeStop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerBase server, ArRobot robot, bool defunct = False) -> ArServerModeStop
        __init__(self, ArServerBase server, ArRobot robot) -> ArServerModeStop
        """
        this = _ArNetworkingPy.new_ArServerModeStop(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeStop
    __del__ = lambda self : None;
    def activate(self):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeStop_activate(self)

    def deactivate(self):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeStop_deactivate(self)

    def stop(self):
        """stop(self)"""
        return _ArNetworkingPy.ArServerModeStop_stop(self)

    def netStop(self, *args):
        """netStop(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeStop_netStop(self, *args)

    def userTask(self):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeStop_userTask(self)

    def checkDefault(self):
        """checkDefault(self)"""
        return _ArNetworkingPy.ArServerModeStop_checkDefault(self)

    def getActionGroup(self):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeStop_getActionGroup(self)

    def addToConfig(self, *args):
        """
        addToConfig(self, ArConfig config, char section = "Teleop settings")
        addToConfig(self, ArConfig config)
        """
        return _ArNetworkingPy.ArServerModeStop_addToConfig(self, *args)

    def setUseLocationDependentDevices(self, *args):
        """
        setUseLocationDependentDevices(self, bool useLocationDependentDevices, bool internal = False)
        setUseLocationDependentDevices(self, bool useLocationDependentDevices)
        """
        return _ArNetworkingPy.ArServerModeStop_setUseLocationDependentDevices(self, *args)

    def getUseLocationDependentDevices(self):
        """getUseLocationDependentDevices(self) -> bool"""
        return _ArNetworkingPy.ArServerModeStop_getUseLocationDependentDevices(self)

ArServerModeStop_swigregister = _ArNetworkingPy.ArServerModeStop_swigregister
ArServerModeStop_swigregister(ArServerModeStop)

class ArServerModeWander(ArServerMode):
    """Proxy of C++ ArServerModeWander class"""
    __swig_setmethods__ = {}
    for _s in [ArServerMode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerModeWander, name, value)
    __swig_getmethods__ = {}
    for _s in [ArServerMode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerModeWander, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerBase server, ArRobot robot) -> ArServerModeWander"""
        this = _ArNetworkingPy.new_ArServerModeWander(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerModeWander
    __del__ = lambda self : None;
    def activate(self):
        """activate(self)"""
        return _ArNetworkingPy.ArServerModeWander_activate(self)

    def deactivate(self):
        """deactivate(self)"""
        return _ArNetworkingPy.ArServerModeWander_deactivate(self)

    def wander(self):
        """wander(self)"""
        return _ArNetworkingPy.ArServerModeWander_wander(self)

    def netWander(self, *args):
        """netWander(self, ArServerClient client, ArNetPacket packet)"""
        return _ArNetworkingPy.ArServerModeWander_netWander(self, *args)

    def userTask(self):
        """userTask(self)"""
        return _ArNetworkingPy.ArServerModeWander_userTask(self)

    def checkDefault(self):
        """checkDefault(self)"""
        return _ArNetworkingPy.ArServerModeWander_checkDefault(self)

    def getActionGroup(self):
        """getActionGroup(self) -> ArActionGroup"""
        return _ArNetworkingPy.ArServerModeWander_getActionGroup(self)

ArServerModeWander_swigregister = _ArNetworkingPy.ArServerModeWander_swigregister
ArServerModeWander_swigregister(ArServerModeWander)

class ArServerSimpleComUC(_object):
    """Proxy of C++ ArServerSimpleComUC class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComUC, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComUC, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleComUC"""
        this = _ArNetworkingPy.new_ArServerSimpleComUC(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComUC
    __del__ = lambda self : None;
    def command(self, *args):
        """command(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimpleComUC_command(self, *args)

    def motionCommand(self, *args):
        """motionCommand(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimpleComUC_motionCommand(self, *args)

ArServerSimpleComUC_swigregister = _ArNetworkingPy.ArServerSimpleComUC_swigregister
ArServerSimpleComUC_swigregister(ArServerSimpleComUC)

class ArServerSimpleComMovementLogging(_object):
    """Proxy of C++ ArServerSimpleComMovementLogging class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComMovementLogging, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComMovementLogging, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot, 
            ArServerHandlerPopup popupHandler = None) -> ArServerSimpleComMovementLogging
        __init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleComMovementLogging
        """
        this = _ArNetworkingPy.new_ArServerSimpleComMovementLogging(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComMovementLogging
    __del__ = lambda self : None;
    def logMovementSentEnable(self):
        """logMovementSentEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementSentEnable(self)

    def logMovementSentDisable(self):
        """logMovementSentDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementSentDisable(self)

    def logMovementReceivedEnable(self):
        """logMovementReceivedEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementReceivedEnable(self)

    def logMovementReceivedDisable(self):
        """logMovementReceivedDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logMovementReceivedDisable(self)

    def logVelocitiesReceivedEnable(self):
        """logVelocitiesReceivedEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logVelocitiesReceivedEnable(self)

    def logVelocitiesReceivedDisable(self):
        """logVelocitiesReceivedDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logVelocitiesReceivedDisable(self)

    def packetsReceivedTrackingEnable(self):
        """packetsReceivedTrackingEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsReceivedTrackingEnable(self)

    def packetsReceivedTrackingDisable(self):
        """packetsReceivedTrackingDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsReceivedTrackingDisable(self)

    def packetsSentTrackingEnable(self):
        """packetsSentTrackingEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsSentTrackingEnable(self)

    def packetsSentTrackingDisable(self):
        """packetsSentTrackingDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_packetsSentTrackingDisable(self)

    def logActionsEnable(self):
        """logActionsEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActionsEnable(self)

    def logActionsDisable(self):
        """logActionsDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActionsDisable(self)

    def logActions(self):
        """logActions(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_logActions(self)

    def popupMovementParams(self):
        """popupMovementParams(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_popupMovementParams(self)

    def resetOdometer(self):
        """resetOdometer(self)"""
        return _ArNetworkingPy.ArServerSimpleComMovementLogging_resetOdometer(self)

ArServerSimpleComMovementLogging_swigregister = _ArNetworkingPy.ArServerSimpleComMovementLogging_swigregister
ArServerSimpleComMovementLogging_swigregister(ArServerSimpleComMovementLogging)

class ArServerSimpleComGyro(_object):
    """Proxy of C++ ArServerSimpleComGyro class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComGyro, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComGyro, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot, 
            ArAnalogGyro gyro) -> ArServerSimpleComGyro
        """
        this = _ArNetworkingPy.new_ArServerSimpleComGyro(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComGyro
    __del__ = lambda self : None;
    def gyroEnable(self):
        """gyroEnable(self)"""
        return _ArNetworkingPy.ArServerSimpleComGyro_gyroEnable(self)

    def gyroDisable(self):
        """gyroDisable(self)"""
        return _ArNetworkingPy.ArServerSimpleComGyro_gyroDisable(self)

ArServerSimpleComGyro_swigregister = _ArNetworkingPy.ArServerSimpleComGyro_swigregister
ArServerSimpleComGyro_swigregister(ArServerSimpleComGyro)

class ArServerSimpleComLogRobotConfig(_object):
    """Proxy of C++ ArServerSimpleComLogRobotConfig class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComLogRobotConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComLogRobotConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands commands, ArRobot robot, ArServerHandlerPopup popupHandler = None) -> ArServerSimpleComLogRobotConfig
        __init__(self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleComLogRobotConfig
        """
        this = _ArNetworkingPy.new_ArServerSimpleComLogRobotConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    def logConfig(self):
        """logConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logConfig(self)

    def logMovementConfig(self):
        """logMovementConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logMovementConfig(self)

    def logOrigConfig(self):
        """logOrigConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_logOrigConfig(self)

    def popupConfig(self):
        """popupConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupConfig(self)

    def popupOrigConfig(self):
        """popupOrigConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupOrigConfig(self)

    def popupMovementConfig(self):
        """popupMovementConfig(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogRobotConfig_popupMovementConfig(self)

    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComLogRobotConfig
    __del__ = lambda self : None;
ArServerSimpleComLogRobotConfig_swigregister = _ArNetworkingPy.ArServerSimpleComLogRobotConfig_swigregister
ArServerSimpleComLogRobotConfig_swigregister(ArServerSimpleComLogRobotConfig)

class ArServerSimpleComLogActions(_object):
    """Proxy of C++ ArServerSimpleComLogActions class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleComLogActions, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleComLogActions, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleComLogActions"""
        this = _ArNetworkingPy.new_ArServerSimpleComLogActions(*args)
        try: self.this.append(this)
        except: self.this = this
    def logActions(self):
        """logActions(self)"""
        return _ArNetworkingPy.ArServerSimpleComLogActions_logActions(self)

    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleComLogActions
    __del__ = lambda self : None;
ArServerSimpleComLogActions_swigregister = _ArNetworkingPy.ArServerSimpleComLogActions_swigregister
ArServerSimpleComLogActions_swigregister(ArServerSimpleComLogActions)

class ArServerSimpleServerCommands(_object):
    """Proxy of C++ ArServerSimpleServerCommands class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleServerCommands, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleServerCommands, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands commands, ArServerBase server, 
            bool addLogConnections = True) -> ArServerSimpleServerCommands
        __init__(self, ArServerHandlerCommands commands, ArServerBase server) -> ArServerSimpleServerCommands
        """
        this = _ArNetworkingPy.new_ArServerSimpleServerCommands(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleServerCommands
    __del__ = lambda self : None;
    def logTerseTracking(self):
        """logTerseTracking(self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logTerseTracking(self)

    def logVerboseTracking(self):
        """logVerboseTracking(self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logVerboseTracking(self)

    def resetTracking(self):
        """resetTracking(self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_resetTracking(self)

    def logConnections(self):
        """logConnections(self)"""
        return _ArNetworkingPy.ArServerSimpleServerCommands_logConnections(self)

ArServerSimpleServerCommands_swigregister = _ArNetworkingPy.ArServerSimpleServerCommands_swigregister
ArServerSimpleServerCommands_swigregister(ArServerSimpleServerCommands)

class ArServerSimplePopup(_object):
    """Proxy of C++ ArServerSimplePopup class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimplePopup, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimplePopup, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerHandlerCommands commands, ArServerHandlerPopup popupHandler) -> ArServerSimplePopup"""
        this = _ArNetworkingPy.new_ArServerSimplePopup(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimplePopup
    __del__ = lambda self : None;
    def simplePopup(self, *args):
        """simplePopup(self, ArArgumentBuilder arg)"""
        return _ArNetworkingPy.ArServerSimplePopup_simplePopup(self, *args)

ArServerSimplePopup_swigregister = _ArNetworkingPy.ArServerSimplePopup_swigregister
ArServerSimplePopup_swigregister(ArServerSimplePopup)

class ArServerSimpleLogRobotDebugPackets(_object):
    """Proxy of C++ ArServerSimpleLogRobotDebugPackets class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleLogRobotDebugPackets, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleLogRobotDebugPackets, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArServerHandlerCommands commands, ArRobot robot, char baseDirectory = "") -> ArServerSimpleLogRobotDebugPackets
        __init__(self, ArServerHandlerCommands commands, ArRobot robot) -> ArServerSimpleLogRobotDebugPackets
        """
        this = _ArNetworkingPy.new_ArServerSimpleLogRobotDebugPackets(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleLogRobotDebugPackets
    __del__ = lambda self : None;
    def startLogging(self, fileName = "robotDebugPacketsLog.txt"):
        """
        startLogging(self, char fileName = "robotDebugPacketsLog.txt") -> bool
        startLogging(self) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_startLogging(self, fileName)

    def stopLogging(self):
        """stopLogging(self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_stopLogging(self)

    def packetHandler(self, *args):
        """packetHandler(self, ArRobotPacket packet) -> bool"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_packetHandler(self, *args)

    def addToInfoGroup(self, *args):
        """
        addToInfoGroup(self, ArStringInfoGroup infoGroup, char name, int whichVal, 
            char format = "%d")
        addToInfoGroup(self, ArStringInfoGroup infoGroup, char name, int whichVal)
        """
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_addToInfoGroup(self, *args)

    def getNumValues(self):
        """getNumValues(self) -> int"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_getNumValues(self)

    def getValue(self, *args):
        """getValue(self, int whichVal) -> int"""
        return _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_getValue(self, *args)

ArServerSimpleLogRobotDebugPackets_swigregister = _ArNetworkingPy.ArServerSimpleLogRobotDebugPackets_swigregister
ArServerSimpleLogRobotDebugPackets_swigregister(ArServerSimpleLogRobotDebugPackets)

class ArServerSimpleConnectionTester(_object):
    """Proxy of C++ ArServerSimpleConnectionTester class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleConnectionTester, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleConnectionTester, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArServerHandlerCommands handlerCommands, ArRobot robot) -> ArServerSimpleConnectionTester"""
        this = _ArNetworkingPy.new_ArServerSimpleConnectionTester(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleConnectionTester
    __del__ = lambda self : None;
    def connectionTestStart(self):
        """connectionTestStart(self)"""
        return _ArNetworkingPy.ArServerSimpleConnectionTester_connectionTestStart(self)

    def connectionTestStop(self):
        """connectionTestStop(self)"""
        return _ArNetworkingPy.ArServerSimpleConnectionTester_connectionTestStop(self)

ArServerSimpleConnectionTester_swigregister = _ArNetworkingPy.ArServerSimpleConnectionTester_swigregister
ArServerSimpleConnectionTester_swigregister(ArServerSimpleConnectionTester)

class ArServerSimpleOpener(_object):
    """Proxy of C++ ArServerSimpleOpener class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerSimpleOpener, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerSimpleOpener, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ArArgumentParser parser, char prefix = "", bool addAriaCallbacks = True) -> ArServerSimpleOpener
        __init__(self, ArArgumentParser parser, char prefix = "") -> ArServerSimpleOpener
        __init__(self, ArArgumentParser parser) -> ArServerSimpleOpener
        """
        this = _ArNetworkingPy.new_ArServerSimpleOpener(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerSimpleOpener
    __del__ = lambda self : None;
    def open(self, *args):
        """
        open(self, ArServerBase server, char baseDirectory = "", int secondsToTryFor = 240) -> bool
        open(self, ArServerBase server, char baseDirectory = "") -> bool
        open(self, ArServerBase server) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleOpener_open(self, *args)

    def parseArgs(self, *args):
        """
        parseArgs(self) -> bool
        parseArgs(self, ArArgumentParser parser) -> bool
        """
        return _ArNetworkingPy.ArServerSimpleOpener_parseArgs(self, *args)

    def logOptions(self):
        """logOptions(self)"""
        return _ArNetworkingPy.ArServerSimpleOpener_logOptions(self)

    def checkAndLog(self):
        """checkAndLog(self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_checkAndLog(self)

    def wasUserFileBad(self):
        """wasUserFileBad(self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_wasUserFileBad(self)

    def didOpenFail(self):
        """didOpenFail(self) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_didOpenFail(self)

    def getPort(self):
        """getPort(self) -> int"""
        return _ArNetworkingPy.ArServerSimpleOpener_getPort(self)

    def setDefaultPort(self, *args):
        """setDefaultPort(self, int port)"""
        return _ArNetworkingPy.ArServerSimpleOpener_setDefaultPort(self, *args)

    def parseFile(self, *args):
        """parseFile(self, char fileName) -> bool"""
        return _ArNetworkingPy.ArServerSimpleOpener_parseFile(self, *args)

    def setServerTcpOnly(self, *args):
        """setServerTcpOnly(self, bool serverTcpOnly)"""
        return _ArNetworkingPy.ArServerSimpleOpener_setServerTcpOnly(self, *args)

    def getServerKey(self):
        """getServerKey(self) -> char"""
        return _ArNetworkingPy.ArServerSimpleOpener_getServerKey(self)

ArServerSimpleOpener_swigregister = _ArNetworkingPy.ArServerSimpleOpener_swigregister
ArServerSimpleOpener_swigregister(ArServerSimpleOpener)

class ArServerUserInfo(_object):
    """Proxy of C++ ArServerUserInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArServerUserInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArServerUserInfo, name)
    __repr__ = _swig_repr
    def __init__(self, baseDirectory = None): 
        """
        __init__(self, char baseDirectory = None) -> ArServerUserInfo
        __init__(self) -> ArServerUserInfo
        """
        this = _ArNetworkingPy.new_ArServerUserInfo(baseDirectory)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArServerUserInfo
    __del__ = lambda self : None;
    def readFile(self, *args):
        """readFile(self, char fileName) -> bool"""
        return _ArNetworkingPy.ArServerUserInfo_readFile(self, *args)

    def setBaseDirectory(self, *args):
        """setBaseDirectory(self, char baseDirectory)"""
        return _ArNetworkingPy.ArServerUserInfo_setBaseDirectory(self, *args)

    def matchUserPassword(self, *args):
        """
        matchUserPassword(self, char user, unsigned char password, char passwordKey, 
            char serverKey, bool logFailureVerbosely = False) -> bool
        matchUserPassword(self, char user, unsigned char password, char passwordKey, 
            char serverKey) -> bool
        """
        return _ArNetworkingPy.ArServerUserInfo_matchUserPassword(self, *args)

    def doNotUse(self):
        """doNotUse(self) -> bool"""
        return _ArNetworkingPy.ArServerUserInfo_doNotUse(self)

    def getUsersGroups(self, *args):
        """getUsersGroups(self, char user) -> std::set<(std::string,ArStrCaseCmpOp,std::allocator<(std::string)>)>"""
        return _ArNetworkingPy.ArServerUserInfo_getUsersGroups(self, *args)

    def logUsers(self):
        """logUsers(self)"""
        return _ArNetworkingPy.ArServerUserInfo_logUsers(self)

ArServerUserInfo_swigregister = _ArNetworkingPy.ArServerUserInfo_swigregister
ArServerUserInfo_swigregister(ArServerUserInfo)

class ArClientHandlerRobotUpdate(_object):
    """Proxy of C++ ArClientHandlerRobotUpdate class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArClientHandlerRobotUpdate, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArClientHandlerRobotUpdate, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ArClientBase client) -> ArClientHandlerRobotUpdate"""
        this = _ArNetworkingPy.new_ArClientHandlerRobotUpdate(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _ArNetworkingPy.delete_ArClientHandlerRobotUpdate
    __del__ = lambda self : None;
    def requestUpdates(self, freq = 100):
        """
        requestUpdates(self, int freq = 100)
        requestUpdates(self)
        """
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_requestUpdates(self, freq)

    def stopUpdates(self):
        """stopUpdates(self)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_stopUpdates(self)

    def addStatusChangedCB(self, *args):
        """addStatusChangedCB(self, ArFunctor1_CString cb)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_addStatusChangedCB(self, *args)

    def remStatusChangedCB(self, *args):
        """remStatusChangedCB(self, ArFunctor1_CString cb)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_remStatusChangedCB(self, *args)

    def addModeChangedCB(self, *args):
        """addModeChangedCB(self, ArFunctor1_CString cb)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_addModeChangedCB(self, *args)

    def remModeChangedCB(self, *args):
        """remModeChangedCB(self, ArFunctor1_CString cb)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_remModeChangedCB(self, *args)

    def lock(self):
        """lock(self)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_lock(self)

    def unlock(self):
        """unlock(self)"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_unlock(self)

    def getX(self):
        """getX(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getX(self)

    def getY(self):
        """getY(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getY(self)

    def getTh(self):
        """getTh(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getTh(self)

    def getPose(self):
        """getPose(self) -> ArPose"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getPose(self)

    def getVel(self):
        """getVel(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getVel(self)

    def getRotVel(self):
        """getRotVel(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getRotVel(self)

    def getLatVel(self):
        """getLatVel(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getLatVel(self)

    def haveStateOfCharge(self):
        """haveStateOfCharge(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_haveStateOfCharge(self)

    def getStateOfCharge(self):
        """getStateOfCharge(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getStateOfCharge(self)

    def haveVoltage(self):
        """haveVoltage(self) -> bool"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_haveVoltage(self)

    def getVoltage(self):
        """getVoltage(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getVoltage(self)

    def getTemperature(self):
        """getTemperature(self) -> double"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getTemperature(self)

    def getStatus(self):
        """getStatus(self) -> char"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getStatus(self)

    def getMode(self):
        """getMode(self) -> char"""
        return _ArNetworkingPy.ArClientHandlerRobotUpdate_getMode(self)

ArClientHandlerRobotUpdate_swigregister = _ArNetworkingPy.ArClientHandlerRobotUpdate_swigregister
ArClientHandlerRobotUpdate_swigregister(ArClientHandlerRobotUpdate)



